rulesync 0.62.0 → 0.64.0

package/dist/index.js

@@ -1,23 +1,35 @@
 #!/usr/bin/env node
-import "./chunk-M7NL7G7A.js";
-import "./chunk-LXTA7DBA.js";
-import "./chunk-PCATT4UZ.js";
-import "./chunk-NETSYSMD.js";
-import "./chunk-YTU3SCQO.js";
-import "./chunk-U4PLVMCG.js";
-import "./chunk-UEAYL4NT.js";
-import "./chunk-2CW2KFB3.js";
-import "./chunk-KUGTKMNW.js";
-import "./chunk-4PSTOKKD.js";
-import "./chunk-MDYDKNXQ.js";
-import "./chunk-GQTMTBX4.js";
+import "./chunk-DMTCLQ4T.js";
+import "./chunk-4NAQ5HL4.js";
+import "./chunk-EID75W45.js";
+import "./chunk-LURFNGH4.js";
+import "./chunk-HHJIL3YZ.js";
+import {
+  ensureDir,
+  fileExists,
+  findFiles,
+  findRuleFiles,
+  logger,
+  readFileContent,
+  removeClaudeGeneratedFiles,
+  removeDirectory,
+  resolvePath,
+  writeFileContent
+} from "./chunk-YPJW7Z5M.js";
+import "./chunk-E2J3UBBK.js";
+import "./chunk-FVPZQEWP.js";
+import "./chunk-JX55DU6Y.js";
+import "./chunk-TQOL7OKY.js";
+import "./chunk-KKWJVA56.js";
+import "./chunk-TBXG53FV.js";
+import "./chunk-6LSN7HSJ.js";
 import {
   ALL_TOOL_TARGETS,
   RulesyncTargetsSchema,
   ToolTargetSchema,
   ToolTargetsSchema,
   isToolTarget
-} from "./chunk-AUUSMVCT.js";
+} from "./chunk-LYVES5YR.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -41,12 +53,20 @@ var ClaudeSettingsSchema = z.looseObject({
   )
 });
 
-// src/types/commands.ts
+// src/types/shared.ts
 import { z as z2 } from "zod/mini";
-var CommandFrontmatterSchema = z2.object({
+var OutputSchema = z2.object({
+  tool: ToolTargetSchema,
+  filepath: z2.string(),
+  content: z2.string()
+});
+var BaseFrontmatterSchema = z2.object({
   description: z2.optional(z2.string())
 });
 
+// src/types/commands.ts
+var CommandFrontmatterSchema = BaseFrontmatterSchema;
+
 // src/types/config.ts
 import { z as z3 } from "zod/mini";
 var ConfigSchema = z3.object({
@@ -62,6 +82,7 @@ var ConfigSchema = z3.object({
 // src/types/config-options.ts
 import { z as z4 } from "zod/mini";
 var OutputPathsSchema = z4.object({
+  amazonqcli: z4.optional(z4.string()),
   augmentcode: z4.optional(z4.string()),
   "augmentcode-legacy": z4.optional(z4.string()),
   copilot: z4.optional(z4.string()),
@@ -69,6 +90,7 @@ var OutputPathsSchema = z4.object({
   cline: z4.optional(z4.string()),
   claudecode: z4.optional(z4.string()),
   codexcli: z4.optional(z4.string()),
+  opencode: z4.optional(z4.string()),
   roo: z4.optional(z4.string()),
   geminicli: z4.optional(z4.string()),
   kiro: z4.optional(z4.string()),
@@ -119,7 +141,7 @@ var MergedConfigSchema = z4.object({
 import { z as z5 } from "zod/mini";
 var McpTransportTypeSchema = z5.enum(["stdio", "sse", "http"]);
 var McpServerBaseSchema = z5.object({
-  command: z5.optional(z5.string()),
+  command: z5.optional(z5.union([z5.string(), z5.array(z5.string())])),
   args: z5.optional(z5.array(z5.string())),
   url: z5.optional(z5.string()),
   httpUrl: z5.optional(z5.string()),
@@ -159,11 +181,6 @@ var RuleFrontmatterSchema = z6.object({
   windsurfOutputFormat: z6.optional(z6.enum(["single-file", "directory"])),
   tags: z6.optional(z6.array(z6.string()))
 });
-var GeneratedOutputSchema = z6.object({
-  tool: ToolTargetSchema,
-  filepath: z6.string(),
-  content: z6.string()
-});
 var GenerateOptionsSchema = z6.object({
   targetTools: z6.optional(ToolTargetsSchema),
   outputDir: z6.optional(z6.string()),
@@ -175,6 +192,7 @@ function getDefaultConfig() {
   return {
     aiRulesDir: ".rulesync",
     outputPaths: {
+      amazonqcli: ".amazonq/rules",
       augmentcode: ".",
       "augmentcode-legacy": ".",
       copilot: ".github/instructions",
@@ -182,6 +200,7 @@ function getDefaultConfig() {
       cline: ".clinerules",
       claudecode: ".",
       codexcli: ".",
+      opencode: ".",
       roo: ".roo/rules",
       geminicli: ".gemini/memories",
       kiro: ".kiro/steering",
@@ -417,11 +436,11 @@ async function addCommand(filename, options = {}) {
     await mkdir(rulesDir, { recursive: true });
     const template = generateRuleTemplate(sanitizedFilename);
     await writeFile(filePath, template, "utf8");
-    console.log(`\u2705 Created rule file: ${filePath}`);
-    console.log(`\u{1F4DD} Edit the file to customize your rules.`);
+    logger.success(`Created rule file: ${filePath}`);
+    logger.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)}`
+    logger.error(
+      `Failed to create rule file: ${error instanceof Error ? error.message : String(error)}`
     );
     process.exit(3);
   }
@@ -461,133 +480,6 @@ async function safeAsyncOperation(operation, errorContext) {
   }
 }
 
-// src/utils/file.ts
-import { mkdir as mkdir2, readdir, readFile, rm, stat, writeFile as writeFile2 } from "fs/promises";
-import { dirname, join as join2 } from "path";
-async function ensureDir(dirPath) {
-  try {
-    await stat(dirPath);
-  } catch {
-    await mkdir2(dirPath, { recursive: true });
-  }
-}
-function resolvePath(relativePath, baseDir) {
-  return baseDir ? join2(baseDir, relativePath) : relativePath;
-}
-async function readFileContent(filepath) {
-  return readFile(filepath, "utf-8");
-}
-async function writeFileContent(filepath, content) {
-  await ensureDir(dirname(filepath));
-  await writeFile2(filepath, content, "utf-8");
-}
-async function fileExists(filepath) {
-  try {
-    await stat(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await readdir(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => join2(dir, file));
-  } catch {
-    return [];
-  }
-}
-async function findRuleFiles(aiRulesDir) {
-  const rulesDir = join2(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}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await rm(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    console.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await rm(filepath);
-    }
-  } catch (error) {
-    console.warn(`Failed to remove file ${filepath}:`, error);
-  }
-}
-async function removeClaudeGeneratedFiles() {
-  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
-  for (const fileOrDir of filesToRemove) {
-    if (fileOrDir.endsWith("/memories")) {
-      await removeDirectory(fileOrDir);
-    } else {
-      await removeFile(fileOrDir);
-    }
-  }
-}
-
-// src/utils/logger.ts
-import { consola } from "consola";
-var Logger = class {
-  _verbose = false;
-  console = 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/config.ts
 async function configCommand(options = {}) {
   if (options.init) {
@@ -799,96 +691,161 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-import { join as join15 } from "path";
+import { join as join12 } from "path";
 
 // src/core/command-generator.ts
-import { join as join6 } from "path";
-
-// src/generators/commands/claudecode.ts
 import { join as join3 } from "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}`);
+
+// src/utils/command-generators.ts
+import { join as join2 } from "path";
+function generateYamlFrontmatter(command, options) {
+  const frontmatterLines = ["---"];
+  if (options?.includeDescription && command.frontmatter.description) {
+    frontmatterLines.push(`description: ${command.frontmatter.description}`);
+  }
+  if (options?.additionalFields) {
+    for (const field of options.additionalFields) {
+      frontmatterLines.push(`${field.key}: ${field.value}`);
     }
-    frontmatter.push("---");
-    const content = `${frontmatter.join("\n")}
+  }
+  frontmatterLines.push("---");
+  return frontmatterLines;
+}
+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 join2(baseDir, subdir, `${flattenedName}.md`);
+}
+function getHierarchicalCommandPath(filename, baseDir, subdir, extension = "md") {
+  const nameWithoutExt = filename.replace(/\.[^/.]+$/, "");
+  const fileWithExt = `${nameWithoutExt}.${extension}`;
+  return join2(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/base.ts
+var BaseCommandGenerator = class {
+  /**
+   * Generate command output for the specified tool
+   */
+  generate(command, outputDir) {
+    const filepath = this.getOutputPath(command.filename, outputDir);
+    const content = this.processContent(command);
     return {
-      tool: "claudecode",
+      tool: this.getToolName(),
       filepath,
       content
     };
   }
+  /**
+   * Get the output path for the command file
+   * Override this method if custom path logic is needed
+   */
   getOutputPath(filename, baseDir) {
-    const flattenedName = filename.replace(/\//g, "-");
-    return join3(baseDir, ".claude", "commands", `${flattenedName}.md`);
+    if (this.supportsHierarchy()) {
+      return getHierarchicalCommandPath(
+        filename,
+        baseDir,
+        this.getCommandsDirectory(),
+        this.getFileExtension()
+      );
+    } else {
+      return getFlattenedCommandPath(filename, baseDir, this.getCommandsDirectory());
+    }
+  }
+  /**
+   * Whether this tool supports hierarchical directory structure
+   * Override to return true for tools that support nested commands
+   */
+  supportsHierarchy() {
+    return false;
+  }
+  /**
+   * Get file extension for the target tool
+   * Override if tool uses different extension than .md
+   */
+  getFileExtension() {
+    return "md";
+  }
+};
+
+// src/generators/commands/claudecode.ts
+var ClaudeCodeCommandGenerator = class extends BaseCommandGenerator {
+  getToolName() {
+    return "claudecode";
+  }
+  getCommandsDirectory() {
+    return ".claude/commands";
+  }
+  processContent(command) {
+    return buildCommandContent(command, { includeDescription: true });
   }
+  // Uses flattened structure by default (supportsHierarchy returns false)
 };
 
 // src/generators/commands/geminicli.ts
-import { join as join4 } from "path";
-var GeminiCliCommandGenerator = class {
-  generate(command, outputDir) {
-    const filepath = this.getOutputPath(command.filename, outputDir);
-    const convertedContent = this.convertSyntax(command.content);
+var GeminiCliCommandGenerator = class extends BaseCommandGenerator {
+  getToolName() {
+    return "geminicli";
+  }
+  getCommandsDirectory() {
+    return ".gemini/commands";
+  }
+  processContent(command) {
+    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}"""`);
-    const content = tomlLines.join("\n") + "\n";
-    return {
-      tool: "geminicli",
-      filepath,
-      content
-    };
-  }
-  getOutputPath(filename, baseDir) {
-    const tomlFilename = filename.replace(/\.md$/, ".toml");
-    const filenameWithExt = tomlFilename.endsWith(".toml") ? tomlFilename : `${tomlFilename}.toml`;
-    return join4(baseDir, ".gemini", "commands", filenameWithExt);
+    return tomlLines.join("\n") + "\n";
   }
-  convertSyntax(content) {
-    let converted = content;
-    converted = converted.replace(/\$ARGUMENTS/g, "{{args}}");
-    converted = converted.replace(/!`([^`]+)`/g, "!{$1}");
-    return converted.trim();
+  supportsHierarchy() {
+    return true;
   }
-  escapeTomlString(str) {
-    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  getFileExtension() {
+    return "toml";
   }
 };
 
 // src/generators/commands/roo.ts
-import { join as join5 } from "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()}
-`;
-    return {
-      tool: "roo",
-      filepath,
-      content
-    };
+var RooCommandGenerator = class extends BaseCommandGenerator {
+  getToolName() {
+    return "roo";
   }
-  getOutputPath(filename, baseDir) {
-    const flattenedName = filename.replace(/\//g, "-");
-    return join5(baseDir, ".roo", "commands", `${flattenedName}.md`);
+  getCommandsDirectory() {
+    return ".roo/commands";
+  }
+  processContent(command) {
+    return buildCommandContent(command, { includeDescription: true });
   }
+  // Uses flattened structure by default (supportsHierarchy returns false)
 };
 
 // src/generators/commands/index.ts
@@ -903,7 +860,26 @@ function getCommandGenerator(tool) {
 
 // src/core/command-parser.ts
 import { basename } from "path";
+
+// src/utils/frontmatter.ts
 import matter from "gray-matter";
+function parseFrontmatter(content, options) {
+  const parsed = matter(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 = [];
@@ -918,14 +894,14 @@ 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 = matter(content);
+  const parsed = parseFrontmatter(content);
   try {
     const validatedData = CommandFrontmatterSchema.parse(parsed.data);
     const filename = basename(filepath, ".md");
@@ -946,7 +922,7 @@ async function parseCommandFile(filepath) {
 
 // src/core/command-generator.ts
 async function generateCommands(projectRoot, baseDir, targets) {
-  const commandsDir = join6(projectRoot, ".rulesync", "commands");
+  const commandsDir = join3(projectRoot, ".rulesync", "commands");
   if (!await fileExists(commandsDir)) {
     return [];
   }
@@ -970,8 +946,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}`
         );
       }
     }
@@ -980,7 +956,7 @@ async function generateCommands(projectRoot, baseDir, targets) {
 }
 
 // src/generators/ignore/shared-factory.ts
-import { join as join7 } from "path";
+import { join as join4 } from "path";
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
@@ -1103,7 +1079,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = join7(outputPath, ignoreConfig.filename);
+  const filepath = join4(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -1690,21 +1666,18 @@ function generateWindsurfIgnore(rules, config, baseDir) {
   return generateIgnoreFile(rules, config, ignoreConfigs.windsurf, baseDir);
 }
 
-// src/generators/rules/augmentcode.ts
-import { join as join10 } from "path";
-
 // src/generators/rules/shared-helpers.ts
-import { join as join9 } from "path";
+import { join as join6 } from "path";
 
 // src/utils/ignore.ts
-import { join as join8 } from "path";
+import { join as join5 } from "path";
 import micromatch from "micromatch";
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = join8(baseDir, ".rulesyncignore");
+  const ignorePath = join5(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -1715,7 +1688,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;
   }
@@ -1758,7 +1731,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: join9(outputDir, relativePath),
+    filepath: join6(outputDir, relativePath),
     content
   });
 }
@@ -1767,7 +1740,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) : join9(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : join6(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -1795,7 +1768,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        join9(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        join6(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -1849,7 +1822,61 @@ function generateIgnoreFile2(patterns, tool) {
   return lines.join("\n");
 }
 
+// src/generators/rules/amazonqcli.ts
+async function generateAmazonqcliConfig(rules, config, baseDir) {
+  const generatorConfig = {
+    tool: "amazonqcli",
+    fileExtension: ".md",
+    generateContent: generateRuleFile,
+    generateRootContent: generateMainRulesFile,
+    rootFilePath: ".amazonq/rules/main.md",
+    generateDetailContent: generateRuleFile,
+    detailSubDir: ".amazonq/rules"
+  };
+  return generateComplexRules(rules, config, generatorConfig, baseDir);
+}
+function generateMainRulesFile(rootRule, detailRules) {
+  const lines = [];
+  if (detailRules.length > 0) {
+    lines.push("# Amazon Q Developer CLI Project Rules");
+    lines.push("");
+    lines.push("This file contains the main project rules. See also:");
+    lines.push("");
+    for (const rule of detailRules) {
+      lines.push(`- ${rule.filename}.md: ${rule.frontmatter.description}`);
+    }
+    lines.push("");
+  }
+  if (rootRule) {
+    if (detailRules.length > 0) {
+      lines.push("## Overview");
+      lines.push("");
+    }
+    lines.push(rootRule.content);
+    lines.push("");
+  } else if (detailRules.length === 0) {
+    lines.push("# Amazon Q Developer CLI Project Rules");
+    lines.push("");
+    lines.push("This file contains project-specific rules and context for Amazon Q Developer CLI.");
+    lines.push("");
+    lines.push("## Development Standards");
+    lines.push("");
+    lines.push("Add your project-specific development standards here.");
+    lines.push("");
+  }
+  return lines.join("\n").trim() + "\n";
+}
+function generateRuleFile(rule) {
+  const lines = [];
+  lines.push(`# ${rule.frontmatter.description || rule.filename}`);
+  lines.push("");
+  lines.push(rule.content.trim());
+  lines.push("");
+  return lines.join("\n");
+}
+
 // src/generators/rules/augmentcode.ts
+import { join as join7 } from "path";
 async function generateAugmentcodeConfig(rules, config, baseDir) {
   const outputs = createOutputsArray();
   rules.forEach((rule) => {
@@ -1858,13 +1885,13 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      join10(".augment", "rules", `${rule.filename}.md`),
-      generateRuleFile(rule)
+      join7(".augment", "rules", `${rule.filename}.md`),
+      generateRuleFile2(rule)
     );
   });
   return outputs;
 }
-function generateRuleFile(rule) {
+function generateRuleFile2(rule) {
   const lines = [];
   lines.push("---");
   let ruleType = "manual";
@@ -1911,7 +1938,7 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-import { join as join11 } from "path";
+import { join as join8 } from "path";
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const generatorConfig = {
     tool: "claudecode",
@@ -1923,7 +1950,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
     updateAdditionalConfig: async (ignorePatterns, baseDir2) => {
-      const settingsPath = resolvePath(join11(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath(join8(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -1960,7 +1987,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 = {};
     }
   }
@@ -1983,11 +2010,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
-import { join as join12 } from "path";
+import { join as join9 } from "path";
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -2011,6 +2038,22 @@ function determineCursorRuleType(frontmatter) {
 }
 var GENERATOR_REGISTRY = {
   // Simple generators - generate one file per rule
+  amazonqcli: {
+    type: "complex",
+    tool: "amazonqcli",
+    fileExtension: ".md",
+    // ignoreFileName omitted - Amazon Q CLI doesn't have native ignore file support yet
+    generateContent: (rule) => {
+      const lines = [];
+      if (rule.frontmatter.description) {
+        lines.push(`# ${rule.frontmatter.description}
+`);
+      }
+      lines.push(rule.content.trim());
+      return lines.join("\n");
+    }
+    // Complex generation handled by existing generator
+  },
   cline: {
     type: "simple",
     tool: "cline",
@@ -2067,7 +2110,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return join12(outputDir, `${baseFilename}.instructions.md`);
+      return join9(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -2107,7 +2150,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return join12(outputDir, `${rule.filename}.mdc`);
+      return join9(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -2143,10 +2186,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return join12(outputDir, ".windsurf-rules");
+        return join9(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = join12(outputDir, ".windsurf", "rules");
-        return join12(rulesDir, `${rule.filename}.md`);
+        const rulesDir = join9(outputDir, ".windsurf", "rules");
+        return join9(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -2177,6 +2220,22 @@ var GENERATOR_REGISTRY = {
       const lines = [];
       if (rule.frontmatter.description) {
         lines.push(`# ${rule.frontmatter.description}
+`);
+      }
+      lines.push(rule.content.trim());
+      return lines.join("\n");
+    }
+    // Complex generation handled by existing generator
+  },
+  opencode: {
+    type: "complex",
+    tool: "opencode",
+    fileExtension: ".md",
+    // ignoreFileName omitted - OpenCode doesn't use dedicated ignore files
+    generateContent: (rule) => {
+      const lines = [];
+      if (rule.frontmatter.description) {
+        lines.push(`# ${rule.frontmatter.description}
 `);
       }
       lines.push(rule.content.trim());
@@ -2219,8 +2278,8 @@ async function generateFromRegistry(tool, rules, config, baseDir) {
     const enhancedConfig = {
       tool: generatorConfig.tool,
       fileExtension: generatorConfig.fileExtension,
-      ignoreFileName: generatorConfig.ignoreFileName,
       generateContent: generatorConfig.generateContent,
+      ...generatorConfig.ignoreFileName && { ignoreFileName: generatorConfig.ignoreFileName },
       ...generatorConfig.generateRootContent && {
         generateRootContent: generatorConfig.generateRootContent
       },
@@ -2250,51 +2309,91 @@ var generateWindsurfConfig = createSimpleGenerator("windsurf");
 var generateKiroConfig = createSimpleGenerator("kiro");
 var generateRooConfig = createSimpleGenerator("roo");
 
+// src/utils/xml-document-generator.ts
+import { XMLBuilder } from "fast-xml-parser";
+function generateRootMarkdownWithXmlDocs(rootRule, memoryRules, config) {
+  const lines = [];
+  if (memoryRules.length > 0) {
+    lines.push(
+      "Please also reference the following documents as needed. In this case, `@` stands for the project root directory."
+    );
+    lines.push("");
+    const documentsData = {
+      Documents: {
+        Document: memoryRules.map((rule) => {
+          const relativePath = `@${config.memorySubDir}/${rule.filename}.md`;
+          const document = {
+            Path: relativePath,
+            Description: rule.frontmatter.description
+          };
+          if (rule.frontmatter.globs.length > 0) {
+            document.FilePatterns = rule.frontmatter.globs.join(", ");
+          }
+          return document;
+        })
+      }
+    };
+    const builder = new XMLBuilder({
+      format: true,
+      ignoreAttributes: false,
+      suppressEmptyNode: false
+    });
+    const xmlContent = builder.build(documentsData);
+    lines.push(xmlContent);
+    lines.push("");
+    lines.push("");
+  }
+  if (rootRule) {
+    lines.push(rootRule.content.trim());
+  } else if (memoryRules.length === 0) {
+    lines.push(`# ${config.fallbackTitle}`);
+    lines.push("");
+    lines.push("No configuration rules have been defined yet.");
+  }
+  return lines.join("\n");
+}
+
 // src/generators/rules/codexcli.ts
 async function generateCodexConfig(rules, config, baseDir) {
   const outputs = [];
-  if (rules.length === 0) {
-    return outputs;
-  }
-  const sortedRules = [...rules].sort((a, b) => {
-    if (a.frontmatter.root === true && b.frontmatter.root !== true) return -1;
-    if (a.frontmatter.root !== true && b.frontmatter.root === true) return 1;
-    return 0;
-  });
-  const concatenatedContent = generateConcatenatedCodexContent(sortedRules);
-  if (concatenatedContent.trim()) {
-    const outputDir = resolveOutputDir(config, "codexcli", baseDir);
-    const filepath = `${outputDir}/codex.md`;
-    outputs.push({
-      tool: "codexcli",
-      filepath,
-      content: concatenatedContent
-    });
-  }
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const ignorePath = resolvePath(".codexignore", baseDir);
-    const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, "codexcli");
-    outputs.push({
+  const nonEmptyRules = rules.filter((rule) => rule.content.trim().length > 0);
+  if (nonEmptyRules.length > 0) {
+    const generatorConfig = {
       tool: "codexcli",
-      filepath: ignorePath,
-      content: ignoreContent
-    });
+      fileExtension: ".md",
+      ignoreFileName: ".codexignore",
+      generateContent: generateCodexMemoryMarkdown,
+      generateDetailContent: generateCodexMemoryMarkdown,
+      generateRootContent: generateCodexRootMarkdown,
+      rootFilePath: "AGENTS.md",
+      detailSubDir: ".codex/memories"
+    };
+    const ruleOutputs = await generateComplexRules(nonEmptyRules, config, generatorConfig, baseDir);
+    outputs.push(...ruleOutputs);
+  } else {
+    const ignorePatterns = await loadIgnorePatterns(baseDir);
+    if (ignorePatterns.patterns.length > 0) {
+      const ignorePath = resolvePath(".codexignore", baseDir);
+      const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, "codexcli");
+      outputs.push({
+        tool: "codexcli",
+        filepath: ignorePath,
+        content: ignoreContent
+      });
+    }
   }
   return outputs;
 }
-function generateConcatenatedCodexContent(rules) {
-  const sections = [];
-  for (const rule of rules) {
-    const content = rule.content.trim();
-    if (!content) {
-      continue;
-    }
-    sections.push(content);
-  }
-  return sections.join("\n\n---\n\n");
+function generateCodexMemoryMarkdown(rule) {
+  return rule.content.trim();
 }
-
+function generateCodexRootMarkdown(rootRule, memoryRules, _baseDir) {
+  return generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
+    memorySubDir: ".codex/memories",
+    fallbackTitle: "OpenAI Codex CLI Configuration"
+  });
+}
+
 // src/generators/rules/geminicli.ts
 async function generateGeminiConfig(rules, config, baseDir) {
   const generatorConfig = {
@@ -2313,28 +2412,10 @@ function generateGeminiMemoryMarkdown(rule) {
   return rule.content.trim();
 }
 function generateGeminiRootMarkdown(rootRule, memoryRules, _baseDir) {
-  const lines = [];
-  if (memoryRules.length > 0) {
-    lines.push("Please also reference the following documents as needed:");
-    lines.push("");
-    lines.push("| Document | Description | File Patterns |");
-    lines.push("|----------|-------------|---------------|");
-    for (const rule of memoryRules) {
-      const relativePath = `@.gemini/memories/${rule.filename}.md`;
-      const filePatterns = rule.frontmatter.globs.length > 0 ? rule.frontmatter.globs.join(", ") : "-";
-      lines.push(`| ${relativePath} | ${rule.frontmatter.description} | ${filePatterns} |`);
-    }
-    lines.push("");
-    lines.push("");
-  }
-  if (rootRule) {
-    lines.push(rootRule.content.trim());
-  } else if (memoryRules.length === 0) {
-    lines.push("# Gemini CLI Configuration");
-    lines.push("");
-    lines.push("No configuration rules have been defined yet.");
-  }
-  return lines.join("\n");
+  return generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
+    memorySubDir: ".gemini/memories",
+    fallbackTitle: "Gemini CLI Configuration"
+  });
 }
 
 // src/generators/rules/junie.ts
@@ -2364,20 +2445,42 @@ function generateGuidelinesMarkdown(rootRule, detailRules) {
   return lines.join("\n").trim();
 }
 
+// src/generators/rules/opencode.ts
+async function generateOpenCodeConfig(rules, config, baseDir) {
+  const generatorConfig = {
+    tool: "opencode",
+    fileExtension: ".md",
+    // ignoreFileName omitted - OpenCode doesn't use dedicated ignore files
+    generateContent: generateOpenCodeMarkdown,
+    generateDetailContent: generateOpenCodeMarkdown,
+    generateRootContent: generateOpenCodeRootMarkdown,
+    rootFilePath: "AGENTS.md",
+    detailSubDir: ".opencode/memories"
+  };
+  return generateComplexRules(rules, config, generatorConfig, baseDir);
+}
+function generateOpenCodeMarkdown(rule) {
+  return rule.content.trim();
+}
+function generateOpenCodeRootMarkdown(rootRule, memoryRules, _baseDir) {
+  return generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
+    memorySubDir: ".opencode/memories",
+    fallbackTitle: "OpenCode Configuration"
+  });
+}
+
 // src/core/generator.ts
 async function generateConfigurations(rules, config, targetTools, baseDir) {
   const outputs = createOutputsArray();
   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);
@@ -2398,6 +2501,8 @@ function filterRulesForTool(rules, tool, config) {
 }
 async function generateForTool(tool, rules, config, baseDir) {
   switch (tool) {
+    case "amazonqcli":
+      return await generateAmazonqcliConfig(rules, config, baseDir);
     case "augmentcode": {
       const augmentRulesOutputs = await generateAugmentcodeConfig(rules, config, baseDir);
       const augmentIgnoreOutputs = await generateAugmentCodeIgnoreFiles(rules, config, baseDir);
@@ -2436,20 +2541,21 @@ async function generateForTool(tool, rules, config, baseDir) {
       const kiroIgnoreOutputs = await generateKiroIgnoreFiles(rules, config, baseDir);
       return [...kiroRulesOutputs, ...kiroIgnoreOutputs];
     }
+    case "opencode":
+      return generateOpenCodeConfig(rules, config, baseDir);
     case "windsurf": {
       const windsurfRulesOutputs = await generateWindsurfConfig(rules, config, baseDir);
       const windsurfIgnoreOutputs = await generateWindsurfIgnore(rules, config, baseDir);
       return [...windsurfRulesOutputs, ...windsurfIgnoreOutputs];
     }
     default:
-      console.warn(`Unknown tool: ${tool}`);
+      logger.warn(`Unknown tool: ${tool}`);
       return null;
   }
 }
 
 // src/core/parser.ts
 import { basename as basename2 } from "path";
-import matter2 from "gray-matter";
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const allRuleFiles = await findRuleFiles(aiRulesDir);
@@ -2457,7 +2563,7 @@ async function parseRulesFromDirectory(aiRulesDir) {
   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 {
@@ -2483,7 +2589,7 @@ ${errors.join("\n")}`);
 }
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = matter2(content);
+  const parsed = parseFrontmatter(content);
   try {
     const validatedData = RuleFrontmatterSchema.parse(parsed.data);
     const frontmatter = {
@@ -2600,30 +2706,63 @@ function parseMcpConfig(projectRoot) {
 async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
   const outputs = [];
   const toolMap = {
-    augmentcode: async (servers, dir) => (await import("./augmentcode-HIZIQG2W.js")).generateAugmentcodeMcpConfiguration(
+    amazonqcli: async (servers, dir) => {
+      const config = {
+        aiRulesDir: ".rulesync",
+        outputPaths: {
+          amazonqcli: ".amazonq/rules",
+          augmentcode: ".",
+          "augmentcode-legacy": ".",
+          copilot: ".github/instructions",
+          cursor: ".cursor/rules",
+          cline: ".clinerules",
+          claudecode: ".",
+          codexcli: ".",
+          opencode: ".",
+          roo: ".roo/rules",
+          geminicli: ".gemini/memories",
+          kiro: ".kiro/steering",
+          junie: ".",
+          windsurf: "."
+        },
+        watchEnabled: false,
+        defaultTargets: []
+      };
+      const results = await (await import("./amazonqcli-WVGYACHI.js")).generateAmazonqcliMcp(
+        servers,
+        config,
+        dir
+      );
+      return results.map((result) => ({ filepath: result.filepath, content: result.content }));
+    },
+    augmentcode: async (servers, dir) => (await import("./augmentcode-DTHPPXWO.js")).generateAugmentcodeMcpConfiguration(
+      servers,
+      dir
+    ),
+    "augmentcode-legacy": async (servers, dir) => (await import("./augmentcode-DTHPPXWO.js")).generateAugmentcodeMcpConfiguration(
       servers,
       dir
     ),
-    "augmentcode-legacy": async (servers, dir) => (await import("./augmentcode-HIZIQG2W.js")).generateAugmentcodeMcpConfiguration(
+    claudecode: async (servers, dir) => (await import("./claudecode-SSYLLUXX.js")).generateClaudeMcpConfiguration(
       servers,
       dir
     ),
-    claudecode: async (servers, dir) => (await import("./claudecode-YTEFACCT.js")).generateClaudeMcpConfiguration(
+    copilot: async (servers, dir) => (await import("./copilot-HSQO7ZCJ.js")).generateCopilotMcpConfiguration(servers, dir),
+    cursor: async (servers, dir) => (await import("./cursor-ZB3XNGBK.js")).generateCursorMcpConfiguration(servers, dir),
+    cline: async (servers, dir) => (await import("./cline-5EUGKNZ6.js")).generateClineMcpConfiguration(servers, dir),
+    codexcli: async (servers, dir) => (await import("./codexcli-IGM2ADYK.js")).generateCodexMcpConfiguration(servers, dir),
+    opencode: async (servers, dir) => (await import("./opencode-SZETJ62M.js")).generateOpenCodeMcpConfiguration(
       servers,
       dir
     ),
-    copilot: async (servers, dir) => (await import("./copilot-MOR3HHJX.js")).generateCopilotMcpConfiguration(servers, dir),
-    cursor: async (servers, dir) => (await import("./cursor-YJGH7W24.js")).generateCursorMcpConfiguration(servers, dir),
-    cline: async (servers, dir) => (await import("./cline-CKNUDEA3.js")).generateClineMcpConfiguration(servers, dir),
-    codexcli: async (servers, dir) => (await import("./codexcli-7SDGYI7D.js")).generateCodexMcpConfiguration(servers, dir),
-    roo: async (servers, dir) => (await import("./roo-L3QTTIPO.js")).generateRooMcpConfiguration(servers, dir),
-    geminicli: async (servers, dir) => (await import("./geminicli-E7KZTZ2G.js")).generateGeminiCliMcpConfiguration(
+    roo: async (servers, dir) => (await import("./roo-KLTWVAKE.js")).generateRooMcpConfiguration(servers, dir),
+    geminicli: async (servers, dir) => (await import("./geminicli-FNRKH5GX.js")).generateGeminiCliMcpConfiguration(
       servers,
       dir
     ),
-    kiro: async (servers, dir) => (await import("./kiro-YDHXY2MA.js")).generateKiroMcpConfiguration(servers, dir),
-    junie: async (servers, dir) => (await import("./junie-5LEQU4BO.js")).generateJunieMcpConfiguration(servers, dir),
-    windsurf: async (servers, dir) => (await import("./windsurf-4P6HEUBV.js")).generateWindsurfMcpConfiguration(
+    kiro: async (servers, dir) => (await import("./kiro-B6WZNLY4.js")).generateKiroMcpConfiguration(servers, dir),
+    junie: async (servers, dir) => (await import("./junie-3YGOSOGF.js")).generateJunieMcpConfiguration(servers, dir),
+    windsurf: async (servers, dir) => (await import("./windsurf-IZEKUAID.js")).generateWindsurfMcpConfiguration(
       servers,
       dir
     )
@@ -2708,13 +2847,13 @@ async function generateCommand(options = {}) {
       logger.info("Deleting existing output directories...");
       const targetTools = config.defaultTargets;
       const deleteTasks = [];
-      const commandsDir = join15(config.aiRulesDir, "commands");
+      const commandsDir = join12(config.aiRulesDir, "commands");
       const hasCommands = await fileExists(commandsDir);
       let hasCommandFiles = false;
       if (hasCommands) {
-        const { readdir: readdir2 } = await import("fs/promises");
+        const { readdir } = await import("fs/promises");
         try {
-          const files = await readdir2(commandsDir);
+          const files = await readdir(commandsDir);
           hasCommandFiles = files.some((file) => file.endsWith(".md"));
         } catch {
           hasCommandFiles = false;
@@ -2723,12 +2862,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory(join15(".augment", "rules")));
-            deleteTasks.push(removeDirectory(join15(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join12(".augment", "rules")));
+            deleteTasks.push(removeDirectory(join12(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory(join15(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join12(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -2742,24 +2881,27 @@ async function generateCommand(options = {}) {
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory(join15(".claude", "commands")));
+              deleteTasks.push(removeDirectory(join12(".claude", "commands")));
             }
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory(join15(".roo", "commands")));
+              deleteTasks.push(removeDirectory(join12(".roo", "commands")));
             }
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory(join15(".gemini", "commands")));
+              deleteTasks.push(removeDirectory(join12(".gemini", "commands")));
             }
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
             break;
+          case "opencode":
+            deleteTasks.push(removeDirectory(config.outputPaths.opencode));
+            break;
           case "windsurf":
             deleteTasks.push(removeDirectory(config.outputPaths.windsurf));
             break;
@@ -2853,11 +2995,13 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join16 } from "path";
+import { join as join13 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join16(process.cwd(), ".gitignore");
+  const gitignorePath = join13(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
+    "**/.amazonq/rules/",
+    "**/.amazonq/mcp.json",
     "**/.github/copilot-instructions.md",
     "**/.github/instructions/",
     "**/.cursor/rules/",
@@ -2867,7 +3011,7 @@ var gitignoreCommand = async () => {
     "**/CLAUDE.md",
     "**/.claude/memories/",
     "**/.claude/commands/",
-    "**/codex.md",
+    "**/AGENTS.md",
     "**/.codexignore",
     "**/.roo/rules/",
     "**/.rooignore",
@@ -2883,6 +3027,9 @@ var gitignoreCommand = async () => {
     "**/.augment-guidelines",
     "**/.junie/guidelines.md",
     "**/.noai",
+    "**/.opencode/memories/",
+    "**/.opencode/commands/",
+    "**/opencode.json",
     "**/.mcp.json",
     "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
@@ -2903,7 +3050,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()}
@@ -2912,174 +3059,20 @@ ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
   writeFileSync2(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
-import { join as join23 } from "path";
-import matter7 from "gray-matter";
-
-// src/parsers/augmentcode.ts
-import { basename as basename3, join as join17 } from "path";
-import matter3 from "gray-matter";
-
-// src/utils/parser-helpers.ts
-function createParseResult() {
-  return { rules: [], errors: [] };
-}
-function addError(result, error) {
-  result.errors.push(error);
-}
-function addRule(result, rule) {
-  if (!result.rules) {
-    result.rules = [];
-  }
-  result.rules.push(rule);
-}
-function addRules(result, rules) {
-  if (!result.rules) {
-    result.rules = [];
-  }
-  result.rules.push(...rules);
-}
-async function safeReadFile(operation, errorContext) {
-  try {
-    const result = await operation();
-    return createSuccessResult(result);
-  } catch (error) {
-    return createErrorResult(error, errorContext);
-  }
-}
-
-// src/parsers/augmentcode.ts
-async function parseAugmentcodeConfiguration(baseDir = process.cwd()) {
-  return parseUnifiedAugmentcode(baseDir, {
-    rulesDir: ".augment/rules",
-    targetName: "augmentcode",
-    filenamePrefix: "augmentcode"
-  });
-}
-async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
-  return parseUnifiedAugmentcode(baseDir, {
-    legacyFilePath: ".augment-guidelines",
-    targetName: "augmentcode-legacy",
-    filenamePrefix: "augmentcode-legacy"
-  });
-}
-async function parseUnifiedAugmentcode(baseDir, config) {
-  const result = createParseResult();
-  if (config.rulesDir) {
-    const rulesDir = join17(baseDir, config.rulesDir);
-    if (await fileExists(rulesDir)) {
-      const rulesResult = await parseAugmentRules(rulesDir, config);
-      addRules(result, rulesResult.rules);
-      result.errors.push(...rulesResult.errors);
-    } else {
-      addError(
-        result,
-        `No AugmentCode configuration found. Expected ${config.rulesDir} directory.`
-      );
-    }
-  }
-  if (config.legacyFilePath) {
-    const legacyPath = join17(baseDir, config.legacyFilePath);
-    if (await fileExists(legacyPath)) {
-      const legacyResult = await parseAugmentGuidelines(legacyPath, config);
-      if (legacyResult.rule) {
-        addRule(result, legacyResult.rule);
-      }
-      result.errors.push(...legacyResult.errors);
-    } else {
-      addError(
-        result,
-        `No AugmentCode legacy configuration found. Expected ${config.legacyFilePath} file.`
-      );
-    }
-  }
-  return { rules: result.rules || [], errors: result.errors };
-}
-async function parseAugmentRules(rulesDir, config) {
-  const rules = [];
-  const errors = [];
-  try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(rulesDir);
-    for (const file of files) {
-      if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = join17(rulesDir, file);
-        try {
-          const rawContent = await readFileContent(filePath);
-          const parsed = matter3(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 isRoot = ruleType === "always";
-          const filename = basename3(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 }
-          };
-          rules.push({
-            frontmatter,
-            content: parsed.content.trim(),
-            filename: `${config.filenamePrefix}-${ruleType}-${filename}`,
-            filepath: filePath
-          });
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
-        }
-      }
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    errors.push(`Failed to read ${config.rulesDir || rulesDir} directory: ${errorMessage}`);
-  }
-  return { rules, errors };
-}
-async function parseAugmentGuidelines(guidelinesPath, config) {
-  const parseResult = await safeReadFile(
-    async () => {
-      const content = await readFileContent(guidelinesPath);
-      if (content.trim()) {
-        const frontmatter = {
-          root: true,
-          // Legacy guidelines become root rules
-          targets: [config.targetName],
-          description: "Legacy AugmentCode guidelines",
-          globs: ["**/*"]
-        };
-        return {
-          frontmatter,
-          content: content.trim(),
-          filename: `${config.filenamePrefix}-guidelines`,
-          filepath: guidelinesPath
-        };
-      }
-      return null;
-    },
-    `Failed to parse ${config.legacyFilePath || guidelinesPath}`
-  );
-  if (parseResult.success) {
-    return { rule: parseResult.result || null, errors: [] };
-  } else {
-    return { rule: null, errors: [parseResult.error || "Unknown error"] };
-  }
-}
+import { join as join20 } from "path";
+import matter2 from "gray-matter";
 
 // src/parsers/shared-helpers.ts
-import { basename as basename4, join as join18 } from "path";
-import matter4 from "gray-matter";
+import { basename as basename3, join as join14 } from "path";
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
@@ -3092,16 +3085,18 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
         let content;
         let frontmatter;
         if (mainFile.useFrontmatter) {
-          const parsed = matter4(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 = {
@@ -3130,27 +3125,33 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
       const dirPath = resolvePath(dirConfig.directory, baseDir);
       if (await fileExists(dirPath)) {
         const result = await safeAsyncOperation(async () => {
-          const { readdir: readdir2 } = await import("fs/promises");
-          const files = await readdir2(dirPath);
+          const { readdir } = await import("fs/promises");
+          const files = await readdir(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = join18(dirPath, file);
+              const filePath = join14(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 = matter4(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 = {
@@ -3275,14 +3276,14 @@ function parseMainFile(content, filepath, config) {
 async function parseMemoryFiles(memoryDir, config) {
   const rules = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(memoryDir);
+    const { readdir } = await import("fs/promises");
+    const files = await readdir(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join18(memoryDir, file);
+        const filePath = join14(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = basename4(file, ".md");
+          const filename = basename3(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -3305,24 +3306,23 @@ async function parseMemoryFiles(memoryDir, config) {
 async function parseCommandsFiles(commandsDir, config) {
   const rules = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(commandsDir);
+    const { readdir } = await import("fs/promises");
+    const files = await readdir(commandsDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join18(commandsDir, file);
+        const filePath = join14(commandsDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = basename4(file, ".md");
+          const filename = basename3(file, ".md");
           let frontmatter;
           let ruleContent;
           try {
-            const parsed = matter4(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 {
@@ -3388,6 +3388,170 @@ async function parseSettingsFile(settingsPath, tool) {
   };
 }
 
+// src/parsers/amazonqcli.ts
+async function parseAmazonqcliConfiguration(baseDir = process.cwd()) {
+  return parseMemoryBasedConfiguration(baseDir, {
+    tool: "amazonqcli",
+    mainFileName: ".amazonq/rules/main.md",
+    memoryDirPath: ".amazonq/rules",
+    settingsPath: ".amazonq/mcp.json",
+    mainDescription: "Main Amazon Q Developer CLI configuration",
+    memoryDescription: "Amazon Q rule",
+    filenamePrefix: "amazonq"
+  });
+}
+
+// src/parsers/augmentcode.ts
+import { basename as basename4, join as join15 } from "path";
+
+// src/utils/parser-helpers.ts
+function createParseResult() {
+  return { rules: [], errors: [] };
+}
+function addError(result, error) {
+  result.errors.push(error);
+}
+function addRule(result, rule) {
+  if (!result.rules) {
+    result.rules = [];
+  }
+  result.rules.push(rule);
+}
+function addRules(result, rules) {
+  if (!result.rules) {
+    result.rules = [];
+  }
+  result.rules.push(...rules);
+}
+async function safeReadFile(operation, errorContext) {
+  try {
+    const result = await operation();
+    return createSuccessResult(result);
+  } catch (error) {
+    return createErrorResult(error, errorContext);
+  }
+}
+
+// src/parsers/augmentcode.ts
+async function parseAugmentcodeConfiguration(baseDir = process.cwd()) {
+  return parseUnifiedAugmentcode(baseDir, {
+    rulesDir: ".augment/rules",
+    targetName: "augmentcode",
+    filenamePrefix: "augmentcode"
+  });
+}
+async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
+  return parseUnifiedAugmentcode(baseDir, {
+    legacyFilePath: ".augment-guidelines",
+    targetName: "augmentcode-legacy",
+    filenamePrefix: "augmentcode-legacy"
+  });
+}
+async function parseUnifiedAugmentcode(baseDir, config) {
+  const result = createParseResult();
+  if (config.rulesDir) {
+    const rulesDir = join15(baseDir, config.rulesDir);
+    if (await fileExists(rulesDir)) {
+      const rulesResult = await parseAugmentRules(rulesDir, config);
+      addRules(result, rulesResult.rules);
+      result.errors.push(...rulesResult.errors);
+    } else {
+      addError(
+        result,
+        `No AugmentCode configuration found. Expected ${config.rulesDir} directory.`
+      );
+    }
+  }
+  if (config.legacyFilePath) {
+    const legacyPath = join15(baseDir, config.legacyFilePath);
+    if (await fileExists(legacyPath)) {
+      const legacyResult = await parseAugmentGuidelines(legacyPath, config);
+      if (legacyResult.rule) {
+        addRule(result, legacyResult.rule);
+      }
+      result.errors.push(...legacyResult.errors);
+    } else {
+      addError(
+        result,
+        `No AugmentCode legacy configuration found. Expected ${config.legacyFilePath} file.`
+      );
+    }
+  }
+  return { rules: result.rules || [], errors: result.errors };
+}
+async function parseAugmentRules(rulesDir, config) {
+  const rules = [];
+  const errors = [];
+  try {
+    const { readdir } = await import("fs/promises");
+    const files = await readdir(rulesDir);
+    for (const file of files) {
+      if (file.endsWith(".md") || file.endsWith(".mdc")) {
+        const filePath = join15(rulesDir, file);
+        try {
+          const rawContent = await readFileContent(filePath);
+          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 = basename4(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.length > 0 && { tags }
+          };
+          rules.push({
+            frontmatter,
+            content: parsed.content.trim(),
+            filename: `${config.filenamePrefix}-${ruleType}-${filename}`,
+            filepath: filePath
+          });
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
+        }
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to read ${config.rulesDir || rulesDir} directory: ${errorMessage}`);
+  }
+  return { rules, errors };
+}
+async function parseAugmentGuidelines(guidelinesPath, config) {
+  const parseResult = await safeReadFile(
+    async () => {
+      const content = await readFileContent(guidelinesPath);
+      if (content.trim()) {
+        const frontmatter = {
+          root: true,
+          // Legacy guidelines become root rules
+          targets: [config.targetName],
+          description: "Legacy AugmentCode guidelines",
+          globs: ["**/*"]
+        };
+        return {
+          frontmatter,
+          content: content.trim(),
+          filename: `${config.filenamePrefix}-guidelines`,
+          filepath: guidelinesPath
+        };
+      }
+      return null;
+    },
+    `Failed to parse ${config.legacyFilePath || guidelinesPath}`
+  );
+  if (parseResult.success) {
+    return { rule: parseResult.result || null, errors: [] };
+  } else {
+    return { rule: null, errors: [parseResult.error || "Unknown error"] };
+  }
+}
+
 // src/parsers/claudecode.ts
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   return parseMemoryBasedConfiguration(baseDir, {
@@ -3423,7 +3587,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-import { join as join19 } from "path";
+import { join as join16 } from "path";
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -3446,8 +3610,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-import { basename as basename5, join as join20 } from "path";
-import matter5 from "gray-matter";
+import { basename as basename5, join as join17 } from "path";
 import { DEFAULT_SCHEMA, FAILSAFE_SCHEMA, load } from "js-yaml";
 import { z as z7 } from "zod/mini";
 var customMatterOptions = {
@@ -3571,12 +3734,12 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = join20(baseDir, ".cursorrules");
+  const cursorFilePath = join17(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = matter5(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"];
@@ -3592,18 +3755,18 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = join20(baseDir, ".cursor", "rules");
+  const cursorRulesDir = join17(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
-      const { readdir: readdir2 } = await import("fs/promises");
-      const files = await readdir2(cursorRulesDir);
+      const { readdir } = await import("fs/promises");
+      const files = await readdir(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = join20(cursorRulesDir, file);
+          const filePath = join17(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = matter5(rawContent, customMatterOptions);
-            const content = parsed.content.trim();
+            const parsed = parseFrontmatter(rawContent, { matterOptions: customMatterOptions });
+            const content = parsed.content;
             if (content) {
               const filename = basename5(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
@@ -3628,7 +3791,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 = join20(baseDir, ".cursorignore");
+  const cursorIgnorePath = join17(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -3641,7 +3804,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = join20(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = join17(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -3691,11 +3854,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-import { join as join21 } from "path";
+import { join as join18 } from "path";
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = join21(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = join18(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -3726,6 +3889,32 @@ async function parseJunieConfiguration(baseDir = process.cwd()) {
   return { rules, errors };
 }
 
+// src/parsers/opencode.ts
+async function parseOpCodeIgnore(opcodeignorePath) {
+  try {
+    const content = await readFileContent(opcodeignorePath);
+    const patterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    return patterns;
+  } catch {
+    return [];
+  }
+}
+async function parseOpenCodeConfiguration(baseDir = process.cwd()) {
+  return parseMemoryBasedConfiguration(baseDir, {
+    tool: "opencode",
+    mainFileName: "AGENTS.md",
+    memoryDirPath: ".opencode/memories",
+    settingsPath: "opencode.json",
+    mainDescription: "Main OpenCode configuration",
+    memoryDescription: "Memory file",
+    filenamePrefix: "opencode",
+    additionalIgnoreFile: {
+      path: ".opcodeignore",
+      parser: parseOpCodeIgnore
+    }
+  });
+}
+
 // src/parsers/roo.ts
 async function parseRooConfiguration(baseDir = process.cwd()) {
   return parseConfigurationFiles(baseDir, {
@@ -3747,9 +3936,8 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/windsurf.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join22 } from "path";
-import matter6 from "gray-matter";
+import { readFile } from "fs/promises";
+import { join as join19 } from "path";
 
 // src/core/importer.ts
 async function importConfiguration(options) {
@@ -3765,10 +3953,17 @@ async function importConfiguration(options) {
   let ignorePatterns;
   let mcpServers;
   if (verbose) {
-    console.log(`Importing ${tool} configuration from ${baseDir}...`);
+    logger.log(`Importing ${tool} configuration from ${baseDir}...`);
   }
   try {
     switch (tool) {
+      case "amazonqcli": {
+        const amazonqResult = await parseAmazonqcliConfiguration(baseDir);
+        rules = amazonqResult.rules;
+        errors.push(...amazonqResult.errors);
+        mcpServers = amazonqResult.mcpServers;
+        break;
+      }
       case "augmentcode": {
         const augmentResult = await parseAugmentcodeConfiguration(baseDir);
         rules = augmentResult.rules;
@@ -3829,6 +4024,14 @@ async function importConfiguration(options) {
         errors.push(...junieResult.errors);
         break;
       }
+      case "opencode": {
+        const opencodeResult = await parseOpenCodeConfiguration(baseDir);
+        rules = opencodeResult.rules;
+        errors.push(...opencodeResult.errors);
+        ignorePatterns = opencodeResult.ignorePatterns;
+        mcpServers = opencodeResult.mcpServers;
+        break;
+      }
       default:
         errors.push(`Unsupported tool: ${tool}`);
         return { success: false, rulesCreated: 0, errors };
@@ -3841,10 +4044,10 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = join23(baseDir, rulesDir);
+  const rulesDirPath = join20(baseDir, rulesDir);
   try {
-    const { mkdir: mkdir3 } = await import("fs/promises");
-    await mkdir3(rulesDirPath, { recursive: true });
+    const { mkdir: mkdir2 } = await import("fs/promises");
+    await mkdir2(rulesDirPath, { recursive: true });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     errors.push(`Failed to create rules directory: ${errorMessage}`);
@@ -3856,22 +4059,22 @@ async function importConfiguration(options) {
       const baseFilename = rule.filename;
       let targetDir = rulesDirPath;
       if (rule.type === "command") {
-        targetDir = join23(rulesDirPath, "commands");
-        const { mkdir: mkdir3 } = await import("fs/promises");
-        await mkdir3(targetDir, { recursive: true });
+        targetDir = join20(rulesDirPath, "commands");
+        const { mkdir: mkdir2 } = await import("fs/promises");
+        await mkdir2(targetDir, { recursive: true });
       } else {
         if (!useLegacyLocation) {
-          targetDir = join23(rulesDirPath, "rules");
-          const { mkdir: mkdir3 } = await import("fs/promises");
-          await mkdir3(targetDir, { recursive: true });
+          targetDir = join20(rulesDirPath, "rules");
+          const { mkdir: mkdir2 } = await import("fs/promises");
+          await mkdir2(targetDir, { recursive: true });
         }
       }
-      const filePath = join23(targetDir, `${baseFilename}.md`);
+      const filePath = join20(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);
@@ -3881,13 +4084,13 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = join23(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = join20(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);
@@ -3897,13 +4100,13 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = join23(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = join20(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);
@@ -3924,10 +4127,10 @@ function generateRuleFileContent(rule) {
       description: rule.frontmatter.description,
       targets: rule.frontmatter.targets
     };
-    const frontmatter2 = matter7.stringify("", simplifiedFrontmatter);
+    const frontmatter2 = matter2.stringify("", simplifiedFrontmatter);
     return frontmatter2 + rule.content;
   }
-  const frontmatter = matter7.stringify("", rule.frontmatter);
+  const frontmatter = matter2.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
 
@@ -3935,6 +4138,7 @@ function generateRuleFileContent(rule) {
 async function importCommand(options = {}) {
   logger.setVerbose(options.verbose || false);
   const tools = [];
+  if (options.amazonqcli) tools.push("amazonqcli");
   if (options.augmentcode) tools.push("augmentcode");
   if (options["augmentcode-legacy"]) tools.push("augmentcode-legacy");
   if (options.claudecode) tools.push("claudecode");
@@ -3943,9 +4147,10 @@ async function importCommand(options = {}) {
   if (options.cline) tools.push("cline");
   if (options.roo) tools.push("roo");
   if (options.geminicli) tools.push("geminicli");
+  if (options.opencode) tools.push("opencode");
   if (tools.length === 0) {
     logger.error(
-      "\u274C Please specify one tool to import from (--augmentcode, --augmentcode-legacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
+      "\u274C Please specify one tool to import from (--amazonqcli, --augmentcode, --augmentcode-legacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli, --opencode)"
     );
     process.exit(1);
   }
@@ -3993,23 +4198,23 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join24 } from "path";
+import { join as join21 } from "path";
 async function initCommand(options = {}) {
   const configResult = await loadConfig();
   const config = configResult.config;
   const aiRulesDir = config.aiRulesDir;
-  console.log("Initializing rulesync...");
+  logger.log("Initializing rulesync...");
   await ensureDir(aiRulesDir);
   const useLegacy = options.legacy ?? config.legacy ?? false;
-  const rulesDir = useLegacy ? aiRulesDir : join24(aiRulesDir, "rules");
+  const rulesDir = useLegacy ? aiRulesDir : join21(aiRulesDir, "rules");
   if (!useLegacy) {
     await ensureDir(rulesDir);
   }
   await createSampleFiles(rulesDir);
-  console.log("\u2705 rulesync initialized successfully!");
-  console.log("\nNext steps:");
-  console.log(`1. Edit rule files in ${rulesDir}/`);
-  console.log("2. Run 'rulesync generate' to create configuration files");
+  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 = {
@@ -4047,36 +4252,36 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = join24(rulesDir, sampleFile.filename);
+  const filepath = join21(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;
@@ -4088,63 +4293,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`);
+      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`);
     }
-    console.log("\n\u{1F4E4} Generated files:");
+    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);
   }
 }
@@ -4153,8 +4358,8 @@ async function validateCommand() {
 import { watch } from "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 = watch(`${config.aiRulesDir}/**/*.md`, {
     ignoreInitial: true,
@@ -4164,26 +4369,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);
   });
@@ -4191,12 +4396,12 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.62.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.64.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").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(
+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("--opencode", "Import from OpenCode (AGENTS.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("--opencode", "Generate only for OpenCode").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)"
 ).option("-v, --verbose", "Verbose output").option("-c, --config <path>", "Path to configuration file").option("--no-config", "Disable configuration file loading").action(async (options) => {
@@ -4212,6 +4417,7 @@ program.command("generate").description("Generate configuration files for AI too
   if (options.geminicli) tools.push("geminicli");
   if (options.junie) tools.push("junie");
   if (options.kiro) tools.push("kiro");
+  if (options.opencode) tools.push("opencode");
   if (options.windsurf) tools.push("windsurf");
   const generateOptions = {
     verbose: options.verbose,