rulesync 0.61.0 → 0.63.0

package/dist/index.cjs

@@ -35,11 +35,11 @@ function isToolTarget(target) {
   if (!target) return false;
   return ALL_TOOL_TARGETS.some((validTarget) => validTarget === target);
 }
-var import_mini, ALL_TOOL_TARGETS, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
+var import_mini2, ALL_TOOL_TARGETS, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
 var init_tool_targets = __esm({
   "src/types/tool-targets.ts"() {
     "use strict";
-    import_mini = require("zod/mini");
+    import_mini2 = require("zod/mini");
     ALL_TOOL_TARGETS = [
       "augmentcode",
       "augmentcode-legacy",
@@ -54,10 +54,10 @@ var init_tool_targets = __esm({
       "junie",
       "windsurf"
     ];
-    ToolTargetSchema = import_mini.z.enum(ALL_TOOL_TARGETS);
-    ToolTargetsSchema = import_mini.z.array(ToolTargetSchema);
-    WildcardTargetSchema = import_mini.z.tuple([import_mini.z.literal("*")]);
-    RulesyncTargetsSchema = import_mini.z.union([ToolTargetsSchema, WildcardTargetSchema]);
+    ToolTargetSchema = import_mini2.z.enum(ALL_TOOL_TARGETS);
+    ToolTargetsSchema = import_mini2.z.array(ToolTargetSchema);
+    WildcardTargetSchema = import_mini2.z.tuple([import_mini2.z.literal("*")]);
+    RulesyncTargetsSchema = import_mini2.z.union([ToolTargetsSchema, WildcardTargetSchema]);
   }
 });
 
@@ -257,7 +257,8 @@ function generateMcpConfigurationFilesFromRegistry(tool, mcpServers, baseDir = "
   return generateMcpConfigurationFiles(mcpServers, generatorConfig, baseDir);
 }
 function generateJunieMcpConfigurationFiles(mcpServers, baseDir = "") {
-  const filepath = baseDir ? `${baseDir}/.junie/mcp-config.json` : ".junie/mcp-config.json";
+  const junieMcpPath = ".junie/mcp/mcp.json";
+  const filepath = baseDir ? `${baseDir}/${junieMcpPath}` : junieMcpPath;
   const config = {
     mcpServers: {}
   };
@@ -1055,94 +1056,36 @@ var import_commander = require("commander");
 var import_promises = require("fs/promises");
 var path = __toESM(require("path"), 1);
 
-// src/utils/config.ts
-init_tool_targets();
-function getDefaultConfig() {
-  return {
-    aiRulesDir: ".rulesync",
-    outputPaths: {
-      augmentcode: ".",
-      "augmentcode-legacy": ".",
-      copilot: ".github/instructions",
-      cursor: ".cursor/rules",
-      cline: ".clinerules",
-      claudecode: ".",
-      codexcli: ".",
-      roo: ".roo/rules",
-      geminicli: ".gemini/memories",
-      kiro: ".kiro/steering",
-      junie: ".",
-      windsurf: "."
-    },
-    watchEnabled: false,
-    defaultTargets: ALL_TOOL_TARGETS.filter((tool) => tool !== "augmentcode-legacy")
-  };
-}
-function resolveTargets(targets, config) {
-  if (targets.length === 1 && targets[0] === "*") {
-    return config.defaultTargets;
-  }
-  const validatedTargets = ToolTargetsSchema.parse(targets);
-  return validatedTargets;
-}
-
-// src/cli/commands/add.ts
-function sanitizeFilename(filename) {
-  return filename.endsWith(".md") ? filename.slice(0, -3) : filename;
-}
-function generateRuleTemplate(filename) {
-  return `---
-root: false
-targets: ["*"]
-description: "Rules for ${filename}"
-globs: []
----
-
-# ${filename.charAt(0).toUpperCase() + filename.slice(1)} Rules
-
-Add your rules here.
-`;
-}
-async function addCommand(filename) {
-  try {
-    const config = getDefaultConfig();
-    const sanitizedFilename = sanitizeFilename(filename);
-    const rulesDir = config.aiRulesDir;
-    const filePath = path.join(rulesDir, `${sanitizedFilename}.md`);
-    await (0, import_promises.mkdir)(rulesDir, { recursive: true });
-    const template = generateRuleTemplate(sanitizedFilename);
-    await (0, import_promises.writeFile)(filePath, template, "utf8");
-    console.log(`\u2705 Created rule file: ${filePath}`);
-    console.log(`\u{1F4DD} Edit the file to customize your rules.`);
-  } catch (error) {
-    console.error(
-      `\u274C Failed to create rule file: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(3);
-  }
-}
-
-// src/cli/commands/config.ts
-var import_node_fs = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
+// src/utils/config-loader.ts
+var import_c12 = require("c12");
+var import_core = require("zod/v4/core");
 
 // src/types/claudecode.ts
-var import_mini2 = require("zod/mini");
-var ClaudeSettingsSchema = import_mini2.z.looseObject({
-  permissions: import_mini2.z._default(
-    import_mini2.z.looseObject({
-      deny: import_mini2.z._default(import_mini2.z.array(import_mini2.z.string()), [])
+var import_mini = require("zod/mini");
+var ClaudeSettingsSchema = import_mini.z.looseObject({
+  permissions: import_mini.z._default(
+    import_mini.z.looseObject({
+      deny: import_mini.z._default(import_mini.z.array(import_mini.z.string()), [])
     }),
     { deny: [] }
   )
 });
 
-// src/types/commands.ts
+// src/types/shared.ts
 var import_mini3 = require("zod/mini");
-var CommandFrontmatterSchema = import_mini3.z.object({
+init_tool_targets();
+var OutputSchema = import_mini3.z.object({
+  tool: ToolTargetSchema,
+  filepath: import_mini3.z.string(),
+  content: import_mini3.z.string()
+});
+var BaseFrontmatterSchema = import_mini3.z.object({
   description: import_mini3.z.optional(import_mini3.z.string())
 });
 
+// src/types/commands.ts
+var CommandFrontmatterSchema = BaseFrontmatterSchema;
+
 // src/types/config.ts
 var import_mini4 = require("zod/mini");
 init_tool_targets();
@@ -1152,7 +1095,8 @@ var ConfigSchema = import_mini4.z.object({
   watchEnabled: import_mini4.z.boolean(),
   defaultTargets: ToolTargetsSchema,
   claudecodeCommands: import_mini4.z.optional(import_mini4.z.string()),
-  geminicliCommands: import_mini4.z.optional(import_mini4.z.string())
+  geminicliCommands: import_mini4.z.optional(import_mini4.z.string()),
+  legacy: import_mini4.z.optional(import_mini4.z.boolean())
 });
 
 // src/types/config-options.ts
@@ -1182,6 +1126,7 @@ var ConfigOptionsSchema = import_mini5.z.object({
   verbose: import_mini5.z.optional(import_mini5.z.boolean()),
   delete: import_mini5.z.optional(import_mini5.z.boolean()),
   baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
+  legacy: import_mini5.z.optional(import_mini5.z.boolean()),
   watch: import_mini5.z.optional(
     import_mini5.z.object({
       enabled: import_mini5.z.optional(import_mini5.z.boolean()),
@@ -1201,6 +1146,7 @@ var MergedConfigSchema = import_mini5.z.object({
   delete: import_mini5.z.optional(import_mini5.z.boolean()),
   baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
   configPath: import_mini5.z.optional(import_mini5.z.string()),
+  legacy: import_mini5.z.optional(import_mini5.z.boolean()),
   watch: import_mini5.z.optional(
     import_mini5.z.object({
       enabled: import_mini5.z.optional(import_mini5.z.boolean()),
@@ -1256,11 +1202,6 @@ var RuleFrontmatterSchema = import_mini7.z.object({
   windsurfOutputFormat: import_mini7.z.optional(import_mini7.z.enum(["single-file", "directory"])),
   tags: import_mini7.z.optional(import_mini7.z.array(import_mini7.z.string()))
 });
-var GeneratedOutputSchema = import_mini7.z.object({
-  tool: ToolTargetSchema,
-  filepath: import_mini7.z.string(),
-  content: import_mini7.z.string()
-});
 var GenerateOptionsSchema = import_mini7.z.object({
   targetTools: import_mini7.z.optional(ToolTargetsSchema),
   outputDir: import_mini7.z.optional(import_mini7.z.string()),
@@ -1270,9 +1211,39 @@ var GenerateOptionsSchema = import_mini7.z.object({
 // src/types/index.ts
 init_tool_targets();
 
+// src/utils/config.ts
+init_tool_targets();
+function getDefaultConfig() {
+  return {
+    aiRulesDir: ".rulesync",
+    outputPaths: {
+      augmentcode: ".",
+      "augmentcode-legacy": ".",
+      copilot: ".github/instructions",
+      cursor: ".cursor/rules",
+      cline: ".clinerules",
+      claudecode: ".",
+      codexcli: ".",
+      roo: ".roo/rules",
+      geminicli: ".gemini/memories",
+      kiro: ".kiro/steering",
+      junie: ".",
+      windsurf: "."
+    },
+    watchEnabled: false,
+    defaultTargets: ALL_TOOL_TARGETS.filter((tool) => tool !== "augmentcode-legacy"),
+    legacy: false
+  };
+}
+function resolveTargets(targets, config) {
+  if (targets.length === 1 && targets[0] === "*") {
+    return config.defaultTargets;
+  }
+  const validatedTargets = ToolTargetsSchema.parse(targets);
+  return validatedTargets;
+}
+
 // src/utils/config-loader.ts
-var import_c12 = require("c12");
-var import_core = require("zod/v4/core");
 var MODULE_NAME = "rulesync";
 async function loadConfig(options = {}) {
   const defaultConfig = getDefaultConfig();
@@ -1459,6 +1430,93 @@ function mergeWithCliOptions(config, cliOptions) {
   return merged;
 }
 
+// src/utils/logger.ts
+var import_consola = require("consola");
+var Logger = class {
+  _verbose = false;
+  console = import_consola.consola.withDefaults({
+    tag: "rulesync"
+  });
+  setVerbose(verbose) {
+    this._verbose = verbose;
+  }
+  get verbose() {
+    return this._verbose;
+  }
+  // Regular log (always shown, regardless of verbose)
+  log(message, ...args) {
+    this.console.log(message, ...args);
+  }
+  // Info level (shown only in verbose mode)
+  info(message, ...args) {
+    if (this._verbose) {
+      this.console.info(message, ...args);
+    }
+  }
+  // Success (always shown)
+  success(message, ...args) {
+    this.console.success(message, ...args);
+  }
+  // Warning (always shown)
+  warn(message, ...args) {
+    this.console.warn(message, ...args);
+  }
+  // Error (always shown)
+  error(message, ...args) {
+    this.console.error(message, ...args);
+  }
+  // Debug level (shown only in verbose mode)
+  debug(message, ...args) {
+    if (this._verbose) {
+      this.console.debug(message, ...args);
+    }
+  }
+};
+var logger = new Logger();
+
+// src/cli/commands/add.ts
+function sanitizeFilename(filename) {
+  return filename.endsWith(".md") ? filename.slice(0, -3) : filename;
+}
+function generateRuleTemplate(filename) {
+  return `---
+root: false
+targets: ["*"]
+description: "Rules for ${filename}"
+globs: []
+---
+
+# ${filename.charAt(0).toUpperCase() + filename.slice(1)} Rules
+
+Add your rules here.
+`;
+}
+async function addCommand(filename, options = {}) {
+  try {
+    const configResult = await loadConfig();
+    const config = configResult.config;
+    const sanitizedFilename = sanitizeFilename(filename);
+    const aiRulesDir = config.aiRulesDir;
+    const useLegacy = options.legacy ?? config.legacy ?? false;
+    const rulesDir = useLegacy ? aiRulesDir : path.join(aiRulesDir, "rules");
+    const filePath = path.join(rulesDir, `${sanitizedFilename}.md`);
+    await (0, import_promises.mkdir)(rulesDir, { recursive: true });
+    const template = generateRuleTemplate(sanitizedFilename);
+    await (0, import_promises.writeFile)(filePath, template, "utf8");
+    logger.success(`Created rule file: ${filePath}`);
+    logger.log(`\u{1F4DD} Edit the file to customize your rules.`);
+  } catch (error) {
+    logger.error(
+      `Failed to create rule file: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(3);
+  }
+}
+
+// src/cli/commands/config.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+
 // src/utils/error.ts
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -1525,10 +1583,23 @@ async function findFiles(dir, extension = ".md") {
     return [];
   }
 }
+async function findRuleFiles(aiRulesDir) {
+  const rulesDir = (0, import_node_path.join)(aiRulesDir, "rules");
+  const newLocationFiles = await findFiles(rulesDir, ".md");
+  const legacyLocationFiles = await findFiles(aiRulesDir, ".md");
+  const newLocationBasenames = new Set(
+    newLocationFiles.map((file) => file.split("/").pop()?.replace(/\.md$/, ""))
+  );
+  const filteredLegacyFiles = legacyLocationFiles.filter((file) => {
+    const basename6 = file.split("/").pop()?.replace(/\.md$/, "");
+    return !newLocationBasenames.has(basename6);
+  });
+  return [...newLocationFiles, ...filteredLegacyFiles];
+}
 async function removeDirectory(dirPath) {
   const dangerousPaths = [".", "/", "~", "src", "node_modules"];
   if (dangerousPaths.includes(dirPath) || dirPath === "") {
-    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
     return;
   }
   try {
@@ -1536,7 +1607,7 @@ async function removeDirectory(dirPath) {
       await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
     }
   } catch (error) {
-    console.warn(`Failed to remove directory ${dirPath}:`, error);
+    logger.warn(`Failed to remove directory ${dirPath}:`, error);
   }
 }
 async function removeFile(filepath) {
@@ -1545,7 +1616,7 @@ async function removeFile(filepath) {
       await (0, import_promises2.rm)(filepath);
     }
   } catch (error) {
-    console.warn(`Failed to remove file ${filepath}:`, error);
+    logger.warn(`Failed to remove file ${filepath}:`, error);
   }
 }
 async function removeClaudeGeneratedFiles() {
@@ -1568,50 +1639,50 @@ async function configCommand(options = {}) {
   await showConfig();
 }
 async function showConfig() {
-  console.log("Loading configuration...\n");
+  logger.log("Loading configuration...\n");
   try {
     const result = await loadConfig();
     if (result.isEmpty) {
-      console.log("No configuration file found. Using default configuration.\n");
+      logger.log("No configuration file found. Using default configuration.\n");
     } else {
-      console.log(`Configuration loaded from: ${result.filepath}
+      logger.log(`Configuration loaded from: ${result.filepath}
 `);
     }
-    console.log("Current configuration:");
-    console.log("=====================");
+    logger.log("Current configuration:");
+    logger.log("=====================");
     const config = result.config;
-    console.log(`
+    logger.log(`
 AI Rules Directory: ${config.aiRulesDir}`);
-    console.log(`
+    logger.log(`
 Default Targets: ${config.defaultTargets.join(", ")}`);
     if (config.exclude && config.exclude.length > 0) {
-      console.log(`Excluded Targets: ${config.exclude.join(", ")}`);
+      logger.log(`Excluded Targets: ${config.exclude.join(", ")}`);
     }
-    console.log("\nOutput Paths:");
+    logger.log("\nOutput Paths:");
     for (const [tool, outputPath] of Object.entries(config.outputPaths)) {
-      console.log(`  ${tool}: ${outputPath}`);
+      logger.log(`  ${tool}: ${outputPath}`);
     }
     if (config.baseDir) {
       const dirs = Array.isArray(config.baseDir) ? config.baseDir : [config.baseDir];
-      console.log(`
+      logger.log(`
 Base Directories: ${dirs.join(", ")}`);
     }
-    console.log(`
+    logger.log(`
 Verbose: ${config.verbose || false}`);
-    console.log(`Delete before generate: ${config.delete || false}`);
+    logger.log(`Delete before generate: ${config.delete || false}`);
     if (config.watch) {
-      console.log("\nWatch Configuration:");
-      console.log(`  Enabled: ${config.watch.enabled || false}`);
+      logger.log("\nWatch Configuration:");
+      logger.log(`  Enabled: ${config.watch.enabled || false}`);
       if (config.watch.interval) {
-        console.log(`  Interval: ${config.watch.interval}ms`);
+        logger.log(`  Interval: ${config.watch.interval}ms`);
       }
       if (config.watch.ignore && config.watch.ignore.length > 0) {
-        console.log(`  Ignore patterns: ${config.watch.ignore.join(", ")}`);
+        logger.log(`  Ignore patterns: ${config.watch.ignore.join(", ")}`);
       }
     }
-    console.log("\nTip: Use 'rulesync config init' to create a configuration file.");
+    logger.log("\nTip: Use 'rulesync config init' to create a configuration file.");
   } catch (error) {
-    console.error(
+    logger.error(
       "\u274C Failed to load configuration:",
       error instanceof Error ? error.message : String(error)
     );
@@ -1632,7 +1703,7 @@ async function initConfig(options) {
   const validFormats = Object.keys(FORMAT_CONFIG);
   const selectedFormat = options.format || "jsonc";
   if (!validFormats.includes(selectedFormat)) {
-    console.error(
+    logger.error(
       `\u274C Invalid format: ${selectedFormat}. Valid formats are: ${validFormats.join(", ")}`
     );
     process.exit(1);
@@ -1648,7 +1719,7 @@ async function initConfig(options) {
       if (result.success) {
         validTargets.push(result.data);
       } else {
-        console.error(`\u274C Invalid target: ${target}`);
+        logger.error(`\u274C Invalid target: ${target}`);
         process.exit(1);
       }
     }
@@ -1662,7 +1733,7 @@ async function initConfig(options) {
       if (result.success) {
         validExcludes.push(result.data);
       } else {
-        console.error(`\u274C Invalid exclude target: ${exclude}`);
+        logger.error(`\u274C Invalid exclude target: ${exclude}`);
         process.exit(1);
       }
     }
@@ -1685,18 +1756,18 @@ async function initConfig(options) {
   try {
     const fs2 = await import("fs/promises");
     await fs2.access(filepath);
-    console.error(`\u274C Configuration file already exists: ${filepath}`);
-    console.log("Remove the existing file or choose a different format.");
+    logger.error(`\u274C Configuration file already exists: ${filepath}`);
+    logger.log("Remove the existing file or choose a different format.");
     process.exit(1);
   } catch {
   }
   try {
     (0, import_node_fs.writeFileSync)(filepath, content, "utf-8");
-    console.log(`\u2705 Created configuration file: ${filepath}`);
-    console.log("\nYou can now customize the configuration to fit your needs.");
-    console.log("Run 'rulesync generate' to use the new configuration.");
+    logger.success(`Created configuration file: ${filepath}`);
+    logger.log("\nYou can now customize the configuration to fit your needs.");
+    logger.log("Run 'rulesync generate' to use the new configuration.");
   } catch (error) {
-    console.error(
+    logger.error(
       `\u274C Failed to create configuration file: ${error instanceof Error ? error.message : String(error)}`
     );
     process.exit(1);
@@ -1770,25 +1841,68 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path15 = require("path");
+var import_node_path13 = require("path");
 
 // src/core/command-generator.ts
-var import_node_path7 = require("path");
+var import_node_path5 = require("path");
 
-// src/generators/commands/claudecode.ts
+// src/utils/command-generators.ts
 var import_node_path3 = require("path");
-var ClaudeCodeCommandGenerator = class {
-  generate(command, outputDir) {
-    const filepath = this.getOutputPath(command.filename, outputDir);
-    const frontmatter = ["---"];
-    if (command.frontmatter.description) {
-      frontmatter.push(`description: ${command.frontmatter.description}`);
+function generateYamlFrontmatter(command, options = {}) {
+  const frontmatter = ["---"];
+  if (options.includeDescription !== false && command.frontmatter.description) {
+    frontmatter.push(`description: ${command.frontmatter.description}`);
+  }
+  if (options.additionalFields) {
+    for (const field of options.additionalFields) {
+      frontmatter.push(`${field.key}: ${field.value}`);
     }
-    frontmatter.push("---");
-    const content = `${frontmatter.join("\n")}
+  }
+  frontmatter.push("---");
+  return frontmatter;
+}
+function buildCommandContent(command, frontmatterOptions) {
+  const frontmatter = generateYamlFrontmatter(command, frontmatterOptions);
+  return `${frontmatter.join("\n")}
 
 ${command.content.trim()}
 `;
+}
+function getFlattenedCommandPath(filename, baseDir, subdir) {
+  const flattenedName = filename.replace(/\//g, "-");
+  return (0, import_node_path3.join)(baseDir, subdir, `${flattenedName}.md`);
+}
+function getHierarchicalCommandPath(filename, baseDir, subdir, extension = "md") {
+  const nameWithoutExt = filename.replace(/\.[^/.]+$/, "");
+  const fileWithExt = `${nameWithoutExt}.${extension}`;
+  return (0, import_node_path3.join)(baseDir, subdir, fileWithExt);
+}
+function escapeTomlString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+var syntaxConverters = {
+  /**
+   * Convert Claude Code syntax to Gemini CLI syntax
+   */
+  toGeminiCli(content) {
+    let converted = content;
+    converted = converted.replace(/\$ARGUMENTS/g, "{{args}}");
+    converted = converted.replace(/!`([^`]+)`/g, "!{$1}");
+    return converted.trim();
+  },
+  /**
+   * Convert to Roo Code syntax (currently identical to Claude Code)
+   */
+  toRooCode(content) {
+    return content.trim();
+  }
+};
+
+// src/generators/commands/claudecode.ts
+var ClaudeCodeCommandGenerator = class {
+  generate(command, outputDir) {
+    const filepath = this.getOutputPath(command.filename, outputDir);
+    const content = buildCommandContent(command);
     return {
       tool: "claudecode",
       filepath,
@@ -1796,20 +1910,18 @@ ${command.content.trim()}
     };
   }
   getOutputPath(filename, baseDir) {
-    const flattenedName = filename.replace(/\//g, "-");
-    return (0, import_node_path3.join)(baseDir, ".claude", "commands", `${flattenedName}.md`);
+    return getFlattenedCommandPath(filename, baseDir, ".claude/commands");
   }
 };
 
 // src/generators/commands/geminicli.ts
-var import_node_path4 = require("path");
 var GeminiCliCommandGenerator = class {
   generate(command, outputDir) {
     const filepath = this.getOutputPath(command.filename, outputDir);
-    const convertedContent = this.convertSyntax(command.content);
+    const convertedContent = syntaxConverters.toGeminiCli(command.content);
     const tomlLines = [];
     if (command.frontmatter.description) {
-      tomlLines.push(`description = "${this.escapeTomlString(command.frontmatter.description)}"`);
+      tomlLines.push(`description = "${escapeTomlString(command.frontmatter.description)}"`);
       tomlLines.push("");
     }
     tomlLines.push(`prompt = """${convertedContent}"""`);
@@ -1821,41 +1933,15 @@ var GeminiCliCommandGenerator = class {
     };
   }
   getOutputPath(filename, baseDir) {
-    const tomlFilename = filename.replace(/\.md$/, ".toml");
-    const filenameWithExt = tomlFilename.endsWith(".toml") ? tomlFilename : `${tomlFilename}.toml`;
-    return (0, import_node_path4.join)(baseDir, ".gemini", "commands", filenameWithExt);
-  }
-  convertSyntax(content) {
-    let converted = content;
-    converted = converted.replace(/\$ARGUMENTS/g, "{{args}}");
-    converted = converted.replace(/!`([^`]+)`/g, "!{$1}");
-    const atSyntaxMatches = converted.match(/@[^\s]+/g);
-    if (atSyntaxMatches) {
-      console.warn(
-        `\u26A0\uFE0F  Warning: @ syntax found (${atSyntaxMatches.join(", ")}). Gemini CLI does not support file content injection. Consider using shell commands or remove these references.`
-      );
-    }
-    return converted.trim();
-  }
-  escapeTomlString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+    return getHierarchicalCommandPath(filename, baseDir, ".gemini/commands", "toml");
   }
 };
 
 // src/generators/commands/roo.ts
-var import_node_path5 = require("path");
 var RooCommandGenerator = class {
   generate(command, outputDir) {
     const filepath = this.getOutputPath(command.filename, outputDir);
-    const frontmatter = ["---"];
-    if (command.frontmatter.description) {
-      frontmatter.push(`description: ${command.frontmatter.description}`);
-    }
-    frontmatter.push("---");
-    const content = `${frontmatter.join("\n")}
-
-${command.content.trim()}
-`;
+    const content = buildCommandContent(command);
     return {
       tool: "roo",
       filepath,
@@ -1863,8 +1949,7 @@ ${command.content.trim()}
     };
   }
   getOutputPath(filename, baseDir) {
-    const flattenedName = filename.replace(/\//g, "-");
-    return (0, import_node_path5.join)(baseDir, ".roo", "commands", `${flattenedName}.md`);
+    return getFlattenedCommandPath(filename, baseDir, ".roo/commands");
   }
 };
 
@@ -1879,8 +1964,27 @@ function getCommandGenerator(tool) {
 }
 
 // src/core/command-parser.ts
-var import_node_path6 = require("path");
+var import_node_path4 = require("path");
+
+// src/utils/frontmatter.ts
 var import_gray_matter = __toESM(require("gray-matter"), 1);
+function parseFrontmatter(content, options) {
+  const parsed = (0, import_gray_matter.default)(content, options?.matterOptions);
+  return {
+    content: parsed.content.trim(),
+    data: parsed.data || {}
+  };
+}
+function extractArrayField(data, key, defaultValue = []) {
+  const value = data[key];
+  return Array.isArray(value) ? value : defaultValue;
+}
+function extractStringField(data, key, defaultValue) {
+  const value = data[key];
+  return typeof value === "string" ? value : defaultValue;
+}
+
+// src/core/command-parser.ts
 async function parseCommandsFromDirectory(commandsDir) {
   const commandFiles = await findFiles(commandsDir, ".md");
   const commands = [];
@@ -1895,17 +1999,17 @@ async function parseCommandsFromDirectory(commandsDir) {
     }
   }
   if (errors.length > 0) {
-    console.warn(`\u26A0\uFE0F  Command parsing errors:
+    logger.warn(`Command parsing errors:
 ${errors.join("\n")}`);
   }
   return commands;
 }
 async function parseCommandFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = (0, import_gray_matter.default)(content);
+  const parsed = parseFrontmatter(content);
   try {
     const validatedData = CommandFrontmatterSchema.parse(parsed.data);
-    const filename = (0, import_node_path6.basename)(filepath, ".md");
+    const filename = (0, import_node_path4.basename)(filepath, ".md");
     return {
       frontmatter: {
         description: validatedData.description
@@ -1923,7 +2027,7 @@ async function parseCommandFile(filepath) {
 
 // src/core/command-generator.ts
 async function generateCommands(projectRoot, baseDir, targets) {
-  const commandsDir = (0, import_node_path7.join)(projectRoot, ".rulesync", "commands");
+  const commandsDir = (0, import_node_path5.join)(projectRoot, ".rulesync", "commands");
   if (!await fileExists(commandsDir)) {
     return [];
   }
@@ -1947,8 +2051,8 @@ async function generateCommands(projectRoot, baseDir, targets) {
         outputs.push(output);
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(
-          `\u274C Failed to generate ${target} command for ${command.filename}: ${errorMessage}`
+        logger.error(
+          `Failed to generate ${target} command for ${command.filename}: ${errorMessage}`
         );
       }
     }
@@ -1957,7 +2061,7 @@ async function generateCommands(projectRoot, baseDir, targets) {
 }
 
 // src/generators/ignore/shared-factory.ts
-var import_node_path8 = require("path");
+var import_node_path6 = require("path");
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
@@ -2080,7 +2184,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path8.join)(outputPath, ignoreConfig.filename);
+  const filepath = (0, import_node_path6.join)(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -2668,20 +2772,20 @@ function generateWindsurfIgnore(rules, config, baseDir) {
 }
 
 // src/generators/rules/augmentcode.ts
-var import_node_path11 = require("path");
+var import_node_path9 = require("path");
 
 // src/generators/rules/shared-helpers.ts
-var import_node_path10 = require("path");
+var import_node_path8 = require("path");
 
 // src/utils/ignore.ts
-var import_node_path9 = require("path");
+var import_node_path7 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path9.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path7.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -2692,7 +2796,7 @@ async function loadIgnorePatterns(baseDir = process.cwd()) {
     cachedIgnorePatterns = { patterns };
     return cachedIgnorePatterns;
   } catch (error) {
-    console.warn(`Failed to read .rulesyncignore: ${error}`);
+    logger.warn(`Failed to read .rulesyncignore: ${error}`);
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
   }
@@ -2735,7 +2839,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: (0, import_node_path10.join)(outputDir, relativePath),
+    filepath: (0, import_node_path8.join)(outputDir, relativePath),
     content
   });
 }
@@ -2744,7 +2848,7 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   for (const rule of rules) {
     const content = generatorConfig.generateContent(rule);
     const outputDir = resolveOutputDir(config, generatorConfig.tool, baseDir);
-    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path10.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path8.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -2772,7 +2876,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        (0, import_node_path10.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        (0, import_node_path8.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -2835,7 +2939,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      (0, import_node_path11.join)(".augment", "rules", `${rule.filename}.md`),
+      (0, import_node_path9.join)(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile(rule)
     );
   });
@@ -2888,7 +2992,7 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path12 = require("path");
+var import_node_path10 = require("path");
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const generatorConfig = {
     tool: "claudecode",
@@ -2900,7 +3004,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
     updateAdditionalConfig: async (ignorePatterns, baseDir2) => {
-      const settingsPath = resolvePath((0, import_node_path12.join)(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath((0, import_node_path10.join)(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -2937,7 +3041,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
       const content = await readFileContent(settingsPath);
       rawSettings = JSON.parse(content);
     } catch {
-      console.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
+      logger.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
       rawSettings = {};
     }
   }
@@ -2960,11 +3064,11 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
   settings.permissions.deny = Array.from(new Set(filteredDeny));
   const jsonContent = JSON.stringify(settings, null, 2);
   await writeFileContent(settingsPath, jsonContent);
-  console.log(`\u2705 Updated Claude Code settings: ${settingsPath}`);
+  logger.success(`Updated Claude Code settings: ${settingsPath}`);
 }
 
 // src/generators/rules/generator-registry.ts
-var import_node_path13 = require("path");
+var import_node_path11 = require("path");
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -3044,7 +3148,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return (0, import_node_path13.join)(outputDir, `${baseFilename}.instructions.md`);
+      return (0, import_node_path11.join)(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -3084,7 +3188,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return (0, import_node_path13.join)(outputDir, `${rule.filename}.mdc`);
+      return (0, import_node_path11.join)(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -3120,10 +3224,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return (0, import_node_path13.join)(outputDir, ".windsurf-rules");
+        return (0, import_node_path11.join)(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = (0, import_node_path13.join)(outputDir, ".windsurf", "rules");
-        return (0, import_node_path13.join)(rulesDir, `${rule.filename}.md`);
+        const rulesDir = (0, import_node_path11.join)(outputDir, ".windsurf", "rules");
+        return (0, import_node_path11.join)(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -3241,7 +3345,7 @@ async function generateCodexConfig(rules, config, baseDir) {
   const concatenatedContent = generateConcatenatedCodexContent(sortedRules);
   if (concatenatedContent.trim()) {
     const outputDir = resolveOutputDir(config, "codexcli", baseDir);
-    const filepath = `${outputDir}/codex.md`;
+    const filepath = `${outputDir}/AGENTS.md`;
     outputs.push({
       tool: "codexcli",
       filepath,
@@ -3347,14 +3451,12 @@ async function generateConfigurations(rules, config, targetTools, baseDir) {
   const toolsToGenerate = targetTools || config.defaultTargets;
   const rootFiles = rules.filter((rule) => rule.frontmatter.root === true);
   if (rootFiles.length === 0) {
-    console.warn(
-      "\u26A0\uFE0F  Warning: No files with 'root: true' found. This may result in incomplete configurations."
-    );
+    logger.warn("No files with 'root: true' found. This may result in incomplete configurations.");
   }
   for (const tool of toolsToGenerate) {
     const relevantRules = filterRulesForTool(rules, tool, config);
     if (relevantRules.length === 0) {
-      console.warn(`No rules found for tool: ${tool}`);
+      logger.warn(`No rules found for tool: ${tool}`);
       continue;
     }
     const toolOutputs = await generateForTool(tool, relevantRules, config, baseDir);
@@ -3419,22 +3521,21 @@ async function generateForTool(tool, rules, config, baseDir) {
       return [...windsurfRulesOutputs, ...windsurfIgnoreOutputs];
     }
     default:
-      console.warn(`Unknown tool: ${tool}`);
+      logger.warn(`Unknown tool: ${tool}`);
       return null;
   }
 }
 
 // src/core/parser.ts
-var import_node_path14 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var import_node_path12 = require("path");
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
-  const allRuleFiles = await findFiles(aiRulesDir, ".md");
+  const allRuleFiles = await findRuleFiles(aiRulesDir);
   const ruleFiles = filterIgnoredFiles(allRuleFiles, ignorePatterns.patterns);
   const rules = [];
   const errors = [];
   if (ignorePatterns.patterns.length > 0) {
-    console.log(`Loaded ${ignorePatterns.patterns.length} ignore patterns from .rulesyncignore`);
+    logger.info(`Loaded ${ignorePatterns.patterns.length} ignore patterns from .rulesyncignore`);
   }
   for (const filepath of ruleFiles) {
     try {
@@ -3460,7 +3561,7 @@ ${errors.join("\n")}`);
 }
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = (0, import_gray_matter2.default)(content);
+  const parsed = parseFrontmatter(content);
   try {
     const validatedData = RuleFrontmatterSchema.parse(parsed.data);
     const frontmatter = {
@@ -3479,7 +3580,7 @@ async function parseRuleFile(filepath) {
       },
       ...validatedData.tags !== void 0 && { tags: validatedData.tags }
     };
-    const filename = (0, import_node_path14.basename)(filepath, ".md");
+    const filename = (0, import_node_path12.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -3648,6 +3749,7 @@ async function generateCommand(options = {}) {
     ...options.baseDirs !== void 0 && { baseDirs: options.baseDirs }
   };
   const config = mergeWithCliOptions(configResult.config, cliOptions);
+  logger.setVerbose(config.verbose || false);
   if (options.tools && options.tools.length > 0) {
     const configTargets = config.defaultTargets;
     const cliTools = options.tools;
@@ -3656,18 +3758,18 @@ async function generateCommand(options = {}) {
     const notInConfig = cliTools.filter((tool) => !configTargetsSet.has(tool));
     const notInCli = configTargets.filter((tool) => !cliToolsSet.has(tool));
     if (notInConfig.length > 0 || notInCli.length > 0) {
-      console.warn("\u26A0\uFE0F  Warning: CLI tool selection differs from configuration!");
-      console.warn(`   Config targets: ${configTargets.join(", ")}`);
-      console.warn(`   CLI specified: ${cliTools.join(", ")}`);
+      logger.warn("\u26A0\uFE0F  Warning: CLI tool selection differs from configuration!");
+      logger.warn(`   Config targets: ${configTargets.join(", ")}`);
+      logger.warn(`   CLI specified: ${cliTools.join(", ")}`);
       if (notInConfig.length > 0) {
-        console.warn(`   Tools specified but not in config: ${notInConfig.join(", ")}`);
+        logger.warn(`   Tools specified but not in config: ${notInConfig.join(", ")}`);
       }
       if (notInCli.length > 0) {
-        console.warn(`   Tools in config but not specified: ${notInCli.join(", ")}`);
+        logger.warn(`   Tools in config but not specified: ${notInCli.join(", ")}`);
       }
-      console.warn("\n   The configuration file targets will be used.");
-      console.warn("   To change targets, update your rulesync config file.");
-      console.warn("");
+      logger.warn("\n   The configuration file targets will be used.");
+      logger.warn("   To change targets, update your rulesync config file.");
+      logger.warn("");
     }
   }
   let baseDirs;
@@ -3678,42 +3780,46 @@ async function generateCommand(options = {}) {
   } else {
     baseDirs = [process.cwd()];
   }
-  if (config.verbose && configResult.filepath) {
-    console.log(`Loaded configuration from: ${configResult.filepath}`);
-  }
-  console.log("Generating configuration files...");
+  logger.info(`Loaded configuration from: ${configResult.filepath}`);
+  logger.log("Generating configuration files...");
   if (!await fileExists(config.aiRulesDir)) {
-    console.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+    logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
     process.exit(1);
   }
   try {
-    if (config.verbose) {
-      console.log(`Parsing rules from ${config.aiRulesDir}...`);
-    }
+    logger.info(`Parsing rules from ${config.aiRulesDir}...`);
     const rules = await parseRulesFromDirectory(config.aiRulesDir);
     if (rules.length === 0) {
-      console.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
+      logger.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
       return;
     }
-    if (config.verbose) {
-      console.log(`Found ${rules.length} rule(s)`);
-      console.log(`Base directories: ${baseDirs.join(", ")}`);
-    }
+    logger.info(`Found ${rules.length} rule(s)`);
+    logger.info(`Base directories: ${baseDirs.join(", ")}`);
     if (config.delete) {
-      if (config.verbose) {
-        console.log("Deleting existing output directories...");
-      }
+      logger.info("Deleting existing output directories...");
       const targetTools = config.defaultTargets;
       const deleteTasks = [];
+      const commandsDir = (0, import_node_path13.join)(config.aiRulesDir, "commands");
+      const hasCommands = await fileExists(commandsDir);
+      let hasCommandFiles = false;
+      if (hasCommands) {
+        const { readdir: readdir2 } = await import("fs/promises");
+        try {
+          const files = await readdir2(commandsDir);
+          hasCommandFiles = files.some((file) => file.endsWith(".md"));
+        } catch {
+          hasCommandFiles = false;
+        }
+      }
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".augment", "rules")));
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "rules")));
+            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -3726,15 +3832,21 @@ async function generateCommand(options = {}) {
             break;
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".claude", "commands")));
+            if (hasCommandFiles) {
+              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".claude", "commands")));
+            }
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".roo", "commands")));
+            if (hasCommandFiles) {
+              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".roo", "commands")));
+            }
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
-            deleteTasks.push(removeDirectory((0, import_node_path15.join)(".gemini", "commands")));
+            if (hasCommandFiles) {
+              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".gemini", "commands")));
+            }
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
@@ -3745,44 +3857,34 @@ async function generateCommand(options = {}) {
         }
       }
       await Promise.all(deleteTasks);
-      if (config.verbose) {
-        console.log("Deleted existing output directories");
-      }
+      logger.info("Deleted existing output directories");
     }
     let totalOutputs = 0;
     for (const baseDir of baseDirs) {
-      if (config.verbose) {
-        console.log(`
+      logger.info(`
 Generating configurations for base directory: ${baseDir}`);
-      }
       const outputs = await generateConfigurations(rules, config, config.defaultTargets, baseDir);
       if (outputs.length === 0) {
-        if (config.verbose) {
-          console.warn(`\u26A0\uFE0F  No configurations generated for ${baseDir}`);
-        }
+        logger.warn(`\u26A0\uFE0F  No configurations generated for ${baseDir}`);
         continue;
       }
       for (const output of outputs) {
         await writeFileContent(output.filepath, output.content);
-        console.log(`\u2705 Generated ${output.tool} configuration: ${output.filepath}`);
+        logger.success(`Generated ${output.tool} configuration: ${output.filepath}`);
       }
       totalOutputs += outputs.length;
     }
     if (totalOutputs === 0) {
-      console.warn("\u26A0\uFE0F  No configurations generated");
+      logger.warn("\u26A0\uFE0F  No configurations generated");
       return;
     }
-    if (config.verbose) {
-      console.log("\nGenerating MCP configurations...");
-    }
+    logger.info("\nGenerating MCP configurations...");
     let totalMcpOutputs = 0;
     for (const baseDir of baseDirs) {
       try {
         const mcpConfig = parseMcpConfig(process.cwd());
         if (!mcpConfig || !mcpConfig.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
-          if (config.verbose) {
-            console.log(`No MCP configuration found for ${baseDir}`);
-          }
+          logger.info(`No MCP configuration found for ${baseDir}`);
           continue;
         }
         const mcpResults = await generateMcpConfigurations(
@@ -3791,27 +3893,21 @@ Generating configurations for base directory: ${baseDir}`);
           config.defaultTargets
         );
         if (mcpResults.length === 0) {
-          if (config.verbose) {
-            console.log(`No MCP configurations generated for ${baseDir}`);
-          }
+          logger.info(`No MCP configurations generated for ${baseDir}`);
           continue;
         }
         for (const result of mcpResults) {
           await writeFileContent(result.filepath, result.content);
-          console.log(`\u2705 Generated ${result.tool} MCP configuration: ${result.filepath}`);
+          logger.success(`Generated ${result.tool} MCP configuration: ${result.filepath}`);
           totalMcpOutputs++;
         }
       } catch (error) {
-        if (config.verbose) {
-          console.error(
-            `\u274C Failed to generate MCP configurations: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+        logger.error(
+          `\u274C Failed to generate MCP configurations: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
     }
-    if (config.verbose) {
-      console.log("\nGenerating command files...");
-    }
+    logger.info("\nGenerating command files...");
     let totalCommandOutputs = 0;
     for (const baseDir of baseDirs) {
       const commandResults = await generateCommands(
@@ -3820,14 +3916,12 @@ Generating configurations for base directory: ${baseDir}`);
         config.defaultTargets
       );
       if (commandResults.length === 0) {
-        if (config.verbose) {
-          console.log(`No commands found for ${baseDir}`);
-        }
+        logger.info(`No commands found for ${baseDir}`);
         continue;
       }
       for (const result of commandResults) {
         await writeFileContent(result.filepath, result.content);
-        console.log(`\u2705 Generated ${result.tool} command: ${result.filepath}`);
+        logger.success(`Generated ${result.tool} command: ${result.filepath}`);
         totalCommandOutputs++;
       }
     }
@@ -3837,22 +3931,22 @@ Generating configurations for base directory: ${baseDir}`);
       if (totalOutputs > 0) parts.push(`${totalOutputs} configurations`);
       if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP configurations`);
       if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
-      console.log(
+      logger.success(
         `
 \u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`
       );
     }
   } catch (error) {
-    console.error("\u274C Failed to generate configurations:", error);
+    logger.error("\u274C Failed to generate configurations:", error);
     process.exit(1);
   }
 }
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path16 = require("path");
+var import_node_path14 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path16.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path14.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -3864,7 +3958,7 @@ var gitignoreCommand = async () => {
     "**/CLAUDE.md",
     "**/.claude/memories/",
     "**/.claude/commands/",
-    "**/codex.md",
+    "**/AGENTS.md",
     "**/.codexignore",
     "**/.roo/rules/",
     "**/.rooignore",
@@ -3900,7 +3994,7 @@ var gitignoreCommand = async () => {
     }
   }
   if (linesToAdd.length === 0) {
-    console.log("\u2705 .gitignore is already up to date");
+    logger.success(".gitignore is already up to date");
     return;
   }
   const newContent = gitignoreContent ? `${gitignoreContent.trimEnd()}
@@ -3909,21 +4003,20 @@ ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
   (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
-  console.log(`\u2705 Added ${linesToAdd.length} rules to .gitignore:`);
+  logger.success(`Added ${linesToAdd.length} rules to .gitignore:`);
   for (const line of linesToAdd) {
     if (!line.startsWith("#")) {
-      console.log(`  ${line}`);
+      logger.log(`  ${line}`);
     }
   }
 };
 
 // src/core/importer.ts
-var import_node_path23 = require("path");
-var import_gray_matter7 = __toESM(require("gray-matter"), 1);
+var import_node_path21 = require("path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/augmentcode.ts
-var import_node_path17 = require("path");
-var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+var import_node_path15 = require("path");
 
 // src/utils/parser-helpers.ts
 function createParseResult() {
@@ -3971,7 +4064,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = (0, import_node_path17.join)(baseDir, config.rulesDir);
+    const rulesDir = (0, import_node_path15.join)(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -3984,7 +4077,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = (0, import_node_path17.join)(baseDir, config.legacyFilePath);
+    const legacyPath = (0, import_node_path15.join)(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -4008,23 +4101,22 @@ async function parseAugmentRules(rulesDir, config) {
     const files = await readdir2(rulesDir);
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = (0, import_node_path17.join)(rulesDir, file);
+        const filePath = (0, import_node_path15.join)(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
-          const parsed = (0, import_gray_matter3.default)(rawContent);
-          const frontmatterData = parsed.data;
-          const ruleType = frontmatterData.type || "manual";
-          const description = frontmatterData.description || "";
-          const tags = Array.isArray(frontmatterData.tags) ? frontmatterData.tags : void 0;
+          const parsed = parseFrontmatter(rawContent);
+          const ruleType = extractStringField(parsed.data, "type", "manual");
+          const description = extractStringField(parsed.data, "description", "");
+          const tags = extractArrayField(parsed.data, "tags");
           const isRoot = ruleType === "always";
-          const filename = (0, import_node_path17.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = (0, import_node_path15.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: [config.targetName],
             description,
             globs: ["**/*"],
             // AugmentCode doesn't use specific globs in the same way
-            ...tags && { tags }
+            ...tags.length > 0 && { tags }
           };
           rules.push({
             frontmatter,
@@ -4075,8 +4167,7 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/shared-helpers.ts
-var import_node_path18 = require("path");
-var import_gray_matter4 = __toESM(require("gray-matter"), 1);
+var import_node_path16 = require("path");
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
@@ -4089,16 +4180,18 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
         let content;
         let frontmatter;
         if (mainFile.useFrontmatter) {
-          const parsed = (0, import_gray_matter4.default)(rawContent);
-          content = parsed.content.trim();
-          const parsedFrontmatter = parsed.data;
+          const parsed = parseFrontmatter(rawContent);
+          content = parsed.content;
           frontmatter = {
             root: mainFile.isRoot ?? false,
             targets: [config.tool],
-            description: parsedFrontmatter.description || mainFile.description,
-            globs: Array.isArray(parsedFrontmatter.globs) ? parsedFrontmatter.globs : ["**/*"],
-            ...parsedFrontmatter.tags && { tags: parsedFrontmatter.tags }
+            description: extractStringField(parsed.data, "description", mainFile.description),
+            globs: extractArrayField(parsed.data, "globs", ["**/*"])
           };
+          const tags = extractArrayField(parsed.data, "tags");
+          if (tags.length > 0) {
+            frontmatter.tags = tags;
+          }
         } else {
           content = rawContent.trim();
           frontmatter = {
@@ -4131,23 +4224,29 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
           const files = await readdir2(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = (0, import_node_path18.join)(dirPath, file);
+              const filePath = (0, import_node_path16.join)(dirPath, file);
               const fileResult = await safeAsyncOperation(async () => {
                 const rawContent = await readFileContent(filePath);
                 let content;
                 let frontmatter;
                 const filename = file.replace(new RegExp(`\\${dirConfig.filePattern}$`), "");
                 if (dirConfig.filePattern === ".instructions.md") {
-                  const parsed = (0, import_gray_matter4.default)(rawContent);
-                  content = parsed.content.trim();
-                  const parsedFrontmatter = parsed.data;
+                  const parsed = parseFrontmatter(rawContent);
+                  content = parsed.content;
                   frontmatter = {
                     root: false,
                     targets: [config.tool],
-                    description: parsedFrontmatter.description || `${dirConfig.description}: ${filename}`,
-                    globs: Array.isArray(parsedFrontmatter.globs) ? parsedFrontmatter.globs : ["**/*"],
-                    ...parsedFrontmatter.tags && { tags: parsedFrontmatter.tags }
+                    description: extractStringField(
+                      parsed.data,
+                      "description",
+                      `${dirConfig.description}: ${filename}`
+                    ),
+                    globs: extractArrayField(parsed.data, "globs", ["**/*"])
                   };
+                  const tags = extractArrayField(parsed.data, "tags");
+                  if (tags.length > 0) {
+                    frontmatter.tags = tags;
+                  }
                 } else {
                   content = rawContent.trim();
                   frontmatter = {
@@ -4276,10 +4375,10 @@ async function parseMemoryFiles(memoryDir, config) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path18.join)(memoryDir, file);
+        const filePath = (0, import_node_path16.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path18.basename)(file, ".md");
+          const filename = (0, import_node_path16.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -4306,20 +4405,19 @@ async function parseCommandsFiles(commandsDir, config) {
     const files = await readdir2(commandsDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path18.join)(commandsDir, file);
+        const filePath = (0, import_node_path16.join)(commandsDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path18.basename)(file, ".md");
+          const filename = (0, import_node_path16.basename)(file, ".md");
           let frontmatter;
           let ruleContent;
           try {
-            const parsed = (0, import_gray_matter4.default)(content);
-            ruleContent = parsed.content.trim();
-            const parsedFrontmatter = parsed.data;
+            const parsed = parseFrontmatter(content);
+            ruleContent = parsed.content;
             frontmatter = {
               root: false,
               targets: [config.tool],
-              description: parsedFrontmatter.description || `Command: ${filename}`,
+              description: extractStringField(parsed.data, "description", `Command: ${filename}`),
               globs: ["**/*"]
             };
           } catch {
@@ -4420,7 +4518,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-var import_node_path19 = require("path");
+var import_node_path17 = require("path");
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -4443,8 +4541,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path20 = require("path");
-var import_gray_matter5 = __toESM(require("gray-matter"), 1);
+var import_node_path18 = require("path");
 var import_js_yaml = require("js-yaml");
 var import_mini8 = require("zod/mini");
 var customMatterOptions = {
@@ -4568,12 +4665,12 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path20.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path18.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = (0, import_gray_matter5.default)(rawContent, customMatterOptions);
-      const content = parsed.content.trim();
+      const parsed = parseFrontmatter(rawContent, { matterOptions: customMatterOptions });
+      const content = parsed.content;
       if (content) {
         const frontmatter = convertCursorMdcFrontmatter(parsed.data, "cursorrules");
         frontmatter.targets = ["cursor"];
@@ -4589,20 +4686,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path20.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path18.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path20.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path18.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = (0, import_gray_matter5.default)(rawContent, customMatterOptions);
-            const content = parsed.content.trim();
+            const parsed = parseFrontmatter(rawContent, { matterOptions: customMatterOptions });
+            const content = parsed.content;
             if (content) {
-              const filename = (0, import_node_path20.basename)(file, ".mdc");
+              const filename = (0, import_node_path18.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -4625,7 +4722,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  const cursorIgnorePath = (0, import_node_path20.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path18.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -4638,7 +4735,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path20.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path18.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -4688,11 +4785,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-var import_node_path21 = require("path");
+var import_node_path19 = require("path");
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = (0, import_node_path21.join)(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = (0, import_node_path19.join)(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -4745,18 +4842,23 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 
 // src/parsers/windsurf.ts
 var import_promises3 = require("fs/promises");
-var import_node_path22 = require("path");
-var import_gray_matter6 = __toESM(require("gray-matter"), 1);
+var import_node_path20 = require("path");
 
 // src/core/importer.ts
 async function importConfiguration(options) {
-  const { tool, baseDir = process.cwd(), rulesDir = ".rulesync", verbose = false } = options;
+  const {
+    tool,
+    baseDir = process.cwd(),
+    rulesDir = ".rulesync",
+    verbose = false,
+    useLegacyLocation = false
+  } = options;
   const errors = [];
   let rules = [];
   let ignorePatterns;
   let mcpServers;
   if (verbose) {
-    console.log(`Importing ${tool} configuration from ${baseDir}...`);
+    logger.log(`Importing ${tool} configuration from ${baseDir}...`);
   }
   try {
     switch (tool) {
@@ -4832,7 +4934,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path23.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path21.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -4847,16 +4949,22 @@ async function importConfiguration(options) {
       const baseFilename = rule.filename;
       let targetDir = rulesDirPath;
       if (rule.type === "command") {
-        targetDir = (0, import_node_path23.join)(rulesDirPath, "commands");
+        targetDir = (0, import_node_path21.join)(rulesDirPath, "commands");
         const { mkdir: mkdir3 } = await import("fs/promises");
         await mkdir3(targetDir, { recursive: true });
+      } else {
+        if (!useLegacyLocation) {
+          targetDir = (0, import_node_path21.join)(rulesDirPath, "rules");
+          const { mkdir: mkdir3 } = await import("fs/promises");
+          await mkdir3(targetDir, { recursive: true });
+        }
       }
-      const filePath = (0, import_node_path23.join)(targetDir, `${baseFilename}.md`);
+      const filePath = (0, import_node_path21.join)(targetDir, `${baseFilename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
       if (verbose) {
-        console.log(`\u2705 Created rule file: ${filePath}`);
+        logger.success(`Created rule file: ${filePath}`);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -4866,13 +4974,13 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path23.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path21.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
       ignoreFileCreated = true;
       if (verbose) {
-        console.log(`\u2705 Created .rulesyncignore with ${ignorePatterns.length} patterns`);
+        logger.success(`Created .rulesyncignore with ${ignorePatterns.length} patterns`);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -4882,13 +4990,13 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path23.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path21.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
       mcpFileCreated = true;
       if (verbose) {
-        console.log(`\u2705 Created .mcp.json with ${Object.keys(mcpServers).length} servers`);
+        logger.success(`Created .mcp.json with ${Object.keys(mcpServers).length} servers`);
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -4909,15 +5017,16 @@ function generateRuleFileContent(rule) {
       description: rule.frontmatter.description,
       targets: rule.frontmatter.targets
     };
-    const frontmatter2 = import_gray_matter7.default.stringify("", simplifiedFrontmatter);
+    const frontmatter2 = import_gray_matter2.default.stringify("", simplifiedFrontmatter);
     return frontmatter2 + rule.content;
   }
-  const frontmatter = import_gray_matter7.default.stringify("", rule.frontmatter);
+  const frontmatter = import_gray_matter2.default.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
 
 // src/cli/commands/import.ts
 async function importCommand(options = {}) {
+  logger.setVerbose(options.verbose || false);
   const tools = [];
   if (options.augmentcode) tools.push("augmentcode");
   if (options["augmentcode-legacy"]) tools.push("augmentcode-legacy");
@@ -4928,66 +5037,74 @@ async function importCommand(options = {}) {
   if (options.roo) tools.push("roo");
   if (options.geminicli) tools.push("geminicli");
   if (tools.length === 0) {
-    console.error(
+    logger.error(
       "\u274C Please specify one tool to import from (--augmentcode, --augmentcode-legacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
     );
     process.exit(1);
   }
   if (tools.length > 1) {
-    console.error(
+    logger.error(
       "\u274C Only one tool can be specified at a time. Please run the import command separately for each tool."
     );
     process.exit(1);
   }
   const tool = tools[0];
   if (!tool) {
-    console.error("Error: No tool specified");
+    logger.error("Error: No tool specified");
     process.exit(1);
   }
-  console.log(`Importing configuration files from ${tool}...`);
+  logger.log(`Importing configuration files from ${tool}...`);
   try {
     const result = await importConfiguration({
       tool,
-      verbose: options.verbose ?? false
+      verbose: options.verbose ?? false,
+      useLegacyLocation: options.legacy ?? false
     });
     if (result.success) {
-      console.log(`\u2705 Imported ${result.rulesCreated} rule(s) from ${tool}`);
+      logger.success(`Imported ${result.rulesCreated} rule(s) from ${tool}`);
       if (result.ignoreFileCreated) {
-        console.log("\u2705 Created .rulesyncignore file from ignore patterns");
+        logger.success("Created .rulesyncignore file from ignore patterns");
       }
       if (result.mcpFileCreated) {
-        console.log("\u2705 Created .rulesync/.mcp.json file from MCP configuration");
+        logger.success("Created .rulesync/.mcp.json file from MCP configuration");
       }
-      console.log("You can now run 'rulesync generate' to create tool-specific configurations.");
+      logger.log("You can now run 'rulesync generate' to create tool-specific configurations.");
     } else if (result.errors.length > 0) {
-      console.warn(`\u26A0\uFE0F  Failed to import from ${tool}: ${result.errors[0]}`);
-      if (options.verbose && result.errors.length > 1) {
-        console.log("\nDetailed errors:");
+      logger.warn(`\u26A0\uFE0F  Failed to import from ${tool}: ${result.errors[0]}`);
+      if (result.errors.length > 1) {
+        logger.info("\nDetailed errors:");
         for (const error of result.errors) {
-          console.log(`  - ${error}`);
+          logger.info(`  - ${error}`);
         }
       }
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`\u274C Error importing from ${tool}: ${errorMessage}`);
+    logger.error(`\u274C Error importing from ${tool}: ${errorMessage}`);
     process.exit(1);
   }
 }
 
 // src/cli/commands/init.ts
-var import_node_path24 = require("path");
-async function initCommand() {
-  const aiRulesDir = ".rulesync";
-  console.log("Initializing rulesync...");
+var import_node_path22 = require("path");
+async function initCommand(options = {}) {
+  const configResult = await loadConfig();
+  const config = configResult.config;
+  const aiRulesDir = config.aiRulesDir;
+  logger.log("Initializing rulesync...");
   await ensureDir(aiRulesDir);
-  await createSampleFiles(aiRulesDir);
-  console.log("\u2705 rulesync initialized successfully!");
-  console.log("\nNext steps:");
-  console.log("1. Edit rule files in .rulesync/");
-  console.log("2. Run 'rulesync generate' to create configuration files");
-}
-async function createSampleFiles(aiRulesDir) {
+  const useLegacy = options.legacy ?? config.legacy ?? false;
+  const rulesDir = useLegacy ? aiRulesDir : (0, import_node_path22.join)(aiRulesDir, "rules");
+  if (!useLegacy) {
+    await ensureDir(rulesDir);
+  }
+  await createSampleFiles(rulesDir);
+  logger.success("rulesync initialized successfully!");
+  logger.log("\nNext steps:");
+  logger.log(`1. Edit rule files in ${rulesDir}/`);
+  logger.log("2. Run 'rulesync generate' to create configuration files");
+}
+async function createSampleFiles(rulesDir) {
   const sampleFile = {
     filename: "overview.md",
     content: `---
@@ -5023,36 +5140,36 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path24.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path22.join)(rulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
-    console.log(`Created ${filepath}`);
+    logger.success(`Created ${filepath}`);
   } else {
-    console.log(`Skipped ${filepath} (already exists)`);
+    logger.log(`Skipped ${filepath} (already exists)`);
   }
 }
 
 // src/cli/commands/status.ts
 async function statusCommand() {
   const config = getDefaultConfig();
-  console.log("rulesync Status");
-  console.log("===============");
+  logger.log("rulesync Status");
+  logger.log("===============");
   const rulesyncExists = await fileExists(config.aiRulesDir);
-  console.log(`
+  logger.log(`
 \u{1F4C1} .rulesync directory: ${rulesyncExists ? "\u2705 Found" : "\u274C Not found"}`);
   if (!rulesyncExists) {
-    console.log("\n\u{1F4A1} Run 'rulesync init' to get started");
+    logger.log("\n\u{1F4A1} Run 'rulesync init' to get started");
     return;
   }
   try {
     const rules = await parseRulesFromDirectory(config.aiRulesDir);
-    console.log(`
+    logger.log(`
 \u{1F4CB} Rules: ${rules.length} total`);
     if (rules.length > 0) {
       const rootRules = rules.filter((r) => r.frontmatter.root).length;
       const nonRootRules = rules.length - rootRules;
-      console.log(`   - Root rules: ${rootRules}`);
-      console.log(`   - Non-root rules: ${nonRootRules}`);
+      logger.log(`   - Root rules: ${rootRules}`);
+      logger.log(`   - Non-root rules: ${nonRootRules}`);
       const targetCounts = { copilot: 0, cursor: 0, cline: 0, claudecode: 0, roo: 0 };
       for (const rule of rules) {
         const targets = rule.frontmatter.targets[0] === "*" ? config.defaultTargets : rule.frontmatter.targets;
@@ -5064,63 +5181,63 @@ async function statusCommand() {
           else if (target === "roo") targetCounts.roo++;
         }
       }
-      console.log("\n\u{1F3AF} Target tool coverage:");
-      console.log(`   - Copilot: ${targetCounts.copilot} rules`);
-      console.log(`   - Cursor: ${targetCounts.cursor} rules`);
-      console.log(`   - Cline: ${targetCounts.cline} rules`);
-      console.log(`   - Claude Code: ${targetCounts.claudecode} rules`);
-      console.log(`   - Roo: ${targetCounts.roo} rules`);
-    }
-    console.log("\n\u{1F4E4} Generated files:");
+      logger.log("\n\u{1F3AF} Target tool coverage:");
+      logger.log(`   - Copilot: ${targetCounts.copilot} rules`);
+      logger.log(`   - Cursor: ${targetCounts.cursor} rules`);
+      logger.log(`   - Cline: ${targetCounts.cline} rules`);
+      logger.log(`   - Claude Code: ${targetCounts.claudecode} rules`);
+      logger.log(`   - Roo: ${targetCounts.roo} rules`);
+    }
+    logger.log("\n\u{1F4E4} Generated files:");
     for (const [tool, outputPath] of Object.entries(config.outputPaths)) {
       const outputExists = await fileExists(outputPath);
-      console.log(`   - ${tool}: ${outputExists ? "\u2705 Generated" : "\u274C Not found"}`);
+      logger.log(`   - ${tool}: ${outputExists ? "\u2705 Generated" : "\u274C Not found"}`);
     }
     if (rules.length > 0) {
-      console.log("\n\u{1F4A1} Run 'rulesync generate' to update configuration files");
+      logger.log("\n\u{1F4A1} Run 'rulesync generate' to update configuration files");
     }
   } catch (error) {
-    console.error("\n\u274C Failed to get status:", error);
+    logger.error("\nFailed to get status:", error);
   }
 }
 
 // src/cli/commands/validate.ts
 async function validateCommand() {
   const config = getDefaultConfig();
-  console.log("Validating rulesync configuration...");
+  logger.log("Validating rulesync configuration...");
   if (!await fileExists(config.aiRulesDir)) {
-    console.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+    logger.error(".rulesync directory not found. Run 'rulesync init' first.");
     process.exit(1);
   }
   try {
     const rules = await parseRulesFromDirectory(config.aiRulesDir);
     if (rules.length === 0) {
-      console.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
+      logger.warn("No rules found in .rulesync directory");
       return;
     }
-    console.log(`Found ${rules.length} rule(s), validating...`);
+    logger.log(`Found ${rules.length} rule(s), validating...`);
     const validation = await validateRules(rules);
     if (validation.warnings.length > 0) {
-      console.log("\n\u26A0\uFE0F  Warnings:");
+      logger.log("\n\u26A0\uFE0F  Warnings:");
       for (const warning of validation.warnings) {
-        console.log(`  - ${warning}`);
+        logger.log(`  - ${warning}`);
       }
     }
     if (validation.errors.length > 0) {
-      console.log("\n\u274C Errors:");
+      logger.log("\nErrors:");
       for (const error of validation.errors) {
-        console.log(`  - ${error}`);
+        logger.log(`  - ${error}`);
       }
     }
     if (validation.isValid) {
-      console.log("\n\u2705 All rules are valid!");
+      logger.success("\nAll rules are valid!");
     } else {
-      console.log(`
-\u274C Validation failed with ${validation.errors.length} error(s)`);
+      logger.log(`
+Validation failed with ${validation.errors.length} error(s)`);
       process.exit(1);
     }
   } catch (error) {
-    console.error("\u274C Failed to validate rules:", error);
+    logger.error("Failed to validate rules:", error);
     process.exit(1);
   }
 }
@@ -5129,8 +5246,8 @@ async function validateCommand() {
 var import_chokidar = require("chokidar");
 async function watchCommand() {
   const config = getDefaultConfig();
-  console.log("\u{1F440} Watching for changes in .rulesync directory...");
-  console.log("Press Ctrl+C to stop watching");
+  logger.log("\u{1F440} Watching for changes in .rulesync directory...");
+  logger.log("Press Ctrl+C to stop watching");
   await generateCommand({ verbose: false });
   const watcher = (0, import_chokidar.watch)(`${config.aiRulesDir}/**/*.md`, {
     ignoreInitial: true,
@@ -5140,26 +5257,26 @@ async function watchCommand() {
   const handleChange = async (path5) => {
     if (isGenerating) return;
     isGenerating = true;
-    console.log(`
+    logger.log(`
 \u{1F4DD} Detected change in ${path5}`);
     try {
       await generateCommand({ verbose: false });
-      console.log("\u2705 Regenerated configuration files");
+      logger.success("Regenerated configuration files");
     } catch (error) {
-      console.error("\u274C Failed to regenerate:", error);
+      logger.error("Failed to regenerate:", error);
     } finally {
       isGenerating = false;
     }
   };
   watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path5) => {
-    console.log(`
+    logger.log(`
 \u{1F5D1}\uFE0F  Removed ${path5}`);
     handleChange(path5);
   }).on("error", (error) => {
-    console.error("\u274C Watcher error:", error);
+    logger.error("Watcher error:", error);
   });
   process.on("SIGINT", () => {
-    console.log("\n\n\u{1F44B} Stopping watcher...");
+    logger.log("\n\n\u{1F44B} Stopping watcher...");
     watcher.close();
     process.exit(0);
   });
@@ -5167,11 +5284,11 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.61.0");
-program.command("init").description("Initialize rulesync in current directory").action(initCommand);
-program.command("add <filename>").description("Add a new rule file").action(addCommand);
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.63.0");
+program.command("init").description("Initialize rulesync in current directory").option("--legacy", "Use legacy file location (.rulesync/*.md instead of .rulesync/rules/*.md)").action(initCommand);
+program.command("add <filename>").description("Add a new rule file").option("--legacy", "Use legacy file location (.rulesync/*.md instead of .rulesync/rules/*.md)").action(addCommand);
 program.command("gitignore").description("Add generated files to .gitignore").action(gitignoreCommand);
-program.command("import").description("Import configurations from AI tools to rulesync format").option("--augmentcode", "Import from AugmentCode (.augment/rules/)").option("--augmentcode-legacy", "Import from AugmentCode legacy format (.augment-guidelines)").option("--claudecode", "Import from Claude Code (CLAUDE.md)").option("--cursor", "Import from Cursor (.cursorrules)").option("--copilot", "Import from GitHub Copilot (.github/copilot-instructions.md)").option("--cline", "Import from Cline (.cline/instructions.md)").option("--roo", "Import from Roo Code (.roo/instructions.md)").option("--geminicli", "Import from Gemini CLI (GEMINI.md)").option("--junie", "Import from JetBrains Junie (.junie/guidelines.md)").option("-v, --verbose", "Verbose output").action(importCommand);
+program.command("import").description("Import configurations from AI tools to rulesync format").option("--augmentcode", "Import from AugmentCode (.augment/rules/)").option("--augmentcode-legacy", "Import from AugmentCode legacy format (.augment-guidelines)").option("--claudecode", "Import from Claude Code (CLAUDE.md)").option("--cursor", "Import from Cursor (.cursorrules)").option("--copilot", "Import from GitHub Copilot (.github/copilot-instructions.md)").option("--cline", "Import from Cline (.cline/instructions.md)").option("--roo", "Import from Roo Code (.roo/instructions.md)").option("--geminicli", "Import from Gemini CLI (GEMINI.md)").option("--junie", "Import from JetBrains Junie (.junie/guidelines.md)").option("-v, --verbose", "Verbose output").option("--legacy", "Use legacy file location (.rulesync/*.md instead of .rulesync/rules/*.md)").action(importCommand);
 program.command("generate").description("Generate configuration files for AI tools").option("--augmentcode", "Generate only for AugmentCode").option("--augmentcode-legacy", "Generate only for AugmentCode legacy format").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--codexcli", "Generate only for OpenAI Codex CLI").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--junie", "Generate only for JetBrains Junie").option("--kiro", "Generate only for Kiro IDE").option("--windsurf", "Generate only for Windsurf").option("--delete", "Delete all existing files in output directories before generating").option(
   "-b, --base-dir <paths>",
   "Base directories to generate files (comma-separated for multiple paths)"