rulesync 0.63.0 → 0.65.0

package/dist/index.cjs

@@ -41,6 +41,7 @@ var init_tool_targets = __esm({
     "use strict";
     import_mini2 = require("zod/mini");
     ALL_TOOL_TARGETS = [
+      "amazonqcli",
       "augmentcode",
       "augmentcode-legacy",
       "copilot",
@@ -48,6 +49,8 @@ var init_tool_targets = __esm({
       "cline",
       "claudecode",
       "codexcli",
+      "opencode",
+      "qwencode",
       "roo",
       "geminicli",
       "kiro",
@@ -61,6 +64,152 @@ var init_tool_targets = __esm({
   }
 });
 
+// src/utils/logger.ts
+var import_consola, Logger, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    import_consola = require("consola");
+    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);
+        }
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/utils/file.ts
+async function ensureDir(dirPath) {
+  try {
+    await (0, import_promises2.stat)(dirPath);
+  } catch {
+    await (0, import_promises2.mkdir)(dirPath, { recursive: true });
+  }
+}
+function resolvePath(relativePath, baseDir) {
+  if (!baseDir) return relativePath;
+  const resolved = (0, import_node_path.resolve)(baseDir, relativePath);
+  const rel = (0, import_node_path.relative)(baseDir, resolved);
+  if (rel.startsWith("..") || (0, import_node_path.resolve)(resolved) !== resolved) {
+    throw new Error(`Path traversal detected: ${relativePath}`);
+  }
+  return resolved;
+}
+async function readFileContent(filepath) {
+  return (0, import_promises2.readFile)(filepath, "utf-8");
+}
+async function writeFileContent(filepath, content) {
+  await ensureDir((0, import_node_path.dirname)(filepath));
+  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
+}
+async function fileExists(filepath) {
+  try {
+    await (0, import_promises2.stat)(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findFiles(dir, extension = ".md") {
+  try {
+    const files = await (0, import_promises2.readdir)(dir);
+    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path.join)(dir, file));
+  } catch {
+    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 === "") {
+    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    logger.warn(`Failed to remove directory ${dirPath}:`, error);
+  }
+}
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await (0, import_promises2.rm)(filepath);
+    }
+  } catch (error) {
+    logger.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);
+    }
+  }
+}
+var import_promises2, import_node_path;
+var init_file = __esm({
+  "src/utils/file.ts"() {
+    "use strict";
+    import_promises2 = require("fs/promises");
+    import_node_path = require("path");
+    init_logger();
+  }
+});
+
 // src/utils/mcp-helpers.ts
 function shouldIncludeServer(server, targetTool) {
   if (!server.targets || server.targets.length === 0) {
@@ -85,6 +234,75 @@ var init_mcp_helpers = __esm({
   }
 });
 
+// src/generators/mcp/amazonqcli.ts
+var amazonqcli_exports = {};
+__export(amazonqcli_exports, {
+  generateAmazonqcliMcp: () => generateAmazonqcliMcp,
+  generateAmazonqcliMcpString: () => generateAmazonqcliMcpString
+});
+async function generateAmazonqcliMcp(mcpServers, config, baseDir) {
+  const outputs = [];
+  const configPaths = [
+    ".amazonq/mcp.json"
+    // Workspace configuration
+    // Note: Global configuration is ~/.aws/amazonq/mcp.json but is user-specific
+    // According to precautions.md, we should not create user-level files
+  ];
+  for (const configPath of configPaths) {
+    const filepath = resolvePath(configPath, baseDir);
+    const content = generateAmazonqcliMcpConfig({ mcpServers });
+    outputs.push({
+      tool: "amazonqcli",
+      filepath,
+      content
+    });
+  }
+  return outputs;
+}
+function generateAmazonqcliMcpString(config) {
+  return generateAmazonqcliMcpConfig(config);
+}
+function generateAmazonqcliMcpConfig(config) {
+  const servers = {};
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "amazonqcli")) {
+      continue;
+    }
+    const amazonqServer = {};
+    if (server.command) {
+      amazonqServer.command = server.command;
+      if (server.args) {
+        amazonqServer.args = server.args;
+      }
+    }
+    if (server.env) {
+      amazonqServer.env = server.env;
+    }
+    if (server.timeout !== void 0) {
+      amazonqServer.timeout = server.timeout;
+    }
+    if (server.disabled !== void 0) {
+      amazonqServer.disabled = server.disabled;
+    }
+    if (server.alwaysAllow) {
+      amazonqServer.autoApprove = server.alwaysAllow;
+    }
+    servers[serverName] = amazonqServer;
+  }
+  const finalConfig = {
+    mcpServers: servers
+  };
+  return `${JSON.stringify(finalConfig, null, 2)}
+`;
+}
+var init_amazonqcli = __esm({
+  "src/generators/mcp/amazonqcli.ts"() {
+    "use strict";
+    init_file();
+    init_mcp_helpers();
+  }
+});
+
 // src/generators/mcp/augmentcode.ts
 var augmentcode_exports = {};
 __export(augmentcode_exports, {
@@ -104,7 +322,10 @@ function generateAugmentcodeMcp(config) {
       name: serverName
     };
     if (server.command) {
-      augmentServer.command = server.command;
+      const command = Array.isArray(server.command) ? server.command[0] : server.command;
+      if (command) {
+        augmentServer.command = command;
+      }
       if (server.args) {
         augmentServer.args = server.args;
       }
@@ -152,7 +373,10 @@ function generateAugmentcodeMcpConfiguration(mcpServers, baseDir = "") {
     const { targets: _, ...serverConfig } = server;
     const augmentServer = {};
     if (serverConfig.command) {
-      augmentServer.command = serverConfig.command;
+      const command = Array.isArray(serverConfig.command) ? serverConfig.command[0] : serverConfig.command;
+      if (command) {
+        augmentServer.command = command;
+      }
       if (serverConfig.args) {
         augmentServer.args = serverConfig.args;
       }
@@ -199,6 +423,17 @@ var init_augmentcode = __esm({
   }
 });
 
+// src/constants/schemas.ts
+var SCHEMA_URLS;
+var init_schemas = __esm({
+  "src/constants/schemas.ts"() {
+    "use strict";
+    SCHEMA_URLS = {
+      OPENCODE: "https://opencode.ai/config.json"
+    };
+  }
+});
+
 // src/generators/mcp/shared-factory.ts
 function generateMcpConfig(config, toolConfig) {
   const servers = {};
@@ -248,7 +483,7 @@ function generateMcpConfigurationFilesFromRegistry(tool, mcpServers, baseDir = "
   if (tool === "junie") {
     return generateJunieMcpConfigurationFiles(mcpServers, baseDir);
   }
-  const customTools = ["copilot", "augmentcode", "roo", "codexcli", "kiro", "geminicli"];
+  const customTools = ["copilot", "augmentcode", "codexcli", "kiro"];
   if (customTools.includes(tool)) {
     throw new Error(
       `Tool ${tool} uses custom configuration logic - use its specific generator function instead`
@@ -297,6 +532,7 @@ var serverTransforms, configWrappers, MCP_GENERATOR_REGISTRY, cursorMcpGenerator
 var init_shared_factory = __esm({
   "src/generators/mcp/shared-factory.ts"() {
     "use strict";
+    init_schemas();
     init_mcp_helpers();
     serverTransforms = {
       /**
@@ -307,7 +543,8 @@ var init_shared_factory = __esm({
         if (server.command) {
           result.command = server.command;
           if (server.args) result.args = server.args;
-        } else if (server.url || server.httpUrl) {
+        }
+        if (server.url || server.httpUrl) {
           const url = server.httpUrl || server.url;
           if (url) result.url = url;
         }
@@ -316,6 +553,25 @@ var init_shared_factory = __esm({
         }
         return result;
       },
+      /**
+       * Roo-specific server transformation (preserves httpUrl, transport, type, etc.)
+       */
+      roo: (server) => {
+        const result = serverTransforms.extended(server);
+        if (server.httpUrl) {
+          if (!server.url) {
+            result.httpUrl = server.httpUrl;
+            delete result.url;
+          }
+        }
+        if (server.transport) {
+          result.transport = server.transport;
+        }
+        if (server.type) {
+          result.type = server.type;
+        }
+        return result;
+      },
       /**
        * Extended server transformation (includes disabled, alwaysAllow, etc.)
        */
@@ -367,6 +623,12 @@ var init_shared_factory = __esm({
       })
     };
     MCP_GENERATOR_REGISTRY = {
+      roo: {
+        target: "roo",
+        configPaths: [".roo/mcp.json"],
+        serverTransform: serverTransforms.roo,
+        configWrapper: configWrappers.mcpServers
+      },
       claudecode: {
         target: "claudecode",
         configPaths: [".mcp.json"],
@@ -493,6 +755,61 @@ var init_shared_factory = __esm({
         configPaths: [".cline/mcp.json"],
         serverTransform: serverTransforms.extended,
         configWrapper: configWrappers.mcpServers
+      },
+      geminicli: {
+        target: "geminicli",
+        configPaths: [".gemini/settings.json"],
+        serverTransform: (server) => {
+          const { targets: _, ...serverConfig } = server;
+          const geminiServer = { ...serverConfig };
+          if (server.env) {
+            geminiServer.env = server.env;
+          }
+          return geminiServer;
+        },
+        configWrapper: configWrappers.mcpServers
+      },
+      opencode: {
+        target: "opencode",
+        configPaths: ["opencode.json"],
+        serverTransform: (server) => {
+          const opencodeServer = {};
+          if (server.command) {
+            opencodeServer.type = "local";
+            opencodeServer.command = Array.isArray(server.command) ? server.command : [server.command];
+            if (server.args) opencodeServer.args = server.args;
+            if (server.env) opencodeServer.environment = server.env;
+            if (server.cwd) opencodeServer.cwd = server.cwd;
+          } else if (server.url || server.httpUrl) {
+            opencodeServer.type = "remote";
+            const url = server.httpUrl || server.url;
+            if (url) opencodeServer.url = url;
+            if (server.headers) opencodeServer.headers = server.headers;
+          }
+          if (server.disabled !== void 0) {
+            opencodeServer.enabled = !server.disabled;
+          } else {
+            opencodeServer.enabled = true;
+          }
+          return opencodeServer;
+        },
+        configWrapper: (servers) => ({
+          $schema: SCHEMA_URLS.OPENCODE,
+          mcp: servers
+        })
+      },
+      qwencode: {
+        target: "qwencode",
+        configPaths: [".qwen/settings.json"],
+        serverTransform: (server) => {
+          const { targets: _, ...serverConfig } = server;
+          const qwenServer = { ...serverConfig };
+          if (server.env) {
+            qwenServer.env = server.env;
+          }
+          return qwenServer;
+        },
+        configWrapper: configWrappers.mcpServers
       }
     };
     cursorMcpGenerator = createMcpGenerator("cursor");
@@ -696,7 +1013,10 @@ function generateCopilotMcp(config, target) {
     if (!shouldIncludeServer(server, "copilot")) continue;
     const copilotServer = {};
     if (server.command) {
-      copilotServer.command = server.command;
+      const command = Array.isArray(server.command) ? server.command[0] : server.command;
+      if (command) {
+        copilotServer.command = command;
+      }
       if (server.args) copilotServer.args = server.args;
     } else if (server.url || server.httpUrl) {
       const url = server.httpUrl || server.url;
@@ -786,53 +1106,10 @@ __export(geminicli_exports, {
   generateGeminiCliMcpConfiguration: () => generateGeminiCliMcpConfiguration
 });
 function generateGeminiCliMcp(config) {
-  return generateMcpConfig(config, {
-    target: "geminicli",
-    configPaths: [".gemini/settings.json"],
-    serverTransform: (server) => {
-      const geminiServer = {};
-      if (server.command) {
-        geminiServer.command = server.command;
-        if (server.args) geminiServer.args = server.args;
-      } else if (server.url || server.httpUrl) {
-        if (server.httpUrl) {
-          geminiServer.httpUrl = server.httpUrl;
-        } else if (server.url) {
-          geminiServer.url = server.url;
-        }
-      }
-      if (server.env) {
-        geminiServer.env = server.env;
-      }
-      if (server.timeout !== void 0) {
-        geminiServer.timeout = server.timeout;
-      }
-      if (server.trust !== void 0) {
-        geminiServer.trust = server.trust;
-      }
-      return geminiServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  });
+  return generateMcpFromRegistry("geminicli", config);
 }
 function generateGeminiCliMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFiles(
-    mcpServers,
-    {
-      target: "geminicli",
-      configPaths: [".gemini/settings.json"],
-      serverTransform: (server) => {
-        const { targets: _, ...serverConfig } = server;
-        const geminiServer = { ...serverConfig };
-        if (server.env) {
-          geminiServer.env = server.env;
-        }
-        return geminiServer;
-      },
-      configWrapper: configWrappers.mcpServers
-    },
-    baseDir
-  );
+  return generateMcpConfigurationFilesFromRegistry("geminicli", mcpServers, baseDir);
 }
 var init_geminicli = __esm({
   "src/generators/mcp/geminicli.ts"() {
@@ -949,6 +1226,25 @@ var init_kiro = __esm({
   }
 });
 
+// src/generators/mcp/qwencode.ts
+var qwencode_exports = {};
+__export(qwencode_exports, {
+  generateQwenCodeMcp: () => generateQwenCodeMcp,
+  generateQwenCodeMcpConfiguration: () => generateQwenCodeMcpConfiguration
+});
+function generateQwenCodeMcp(config) {
+  return generateMcpFromRegistry("qwencode", config);
+}
+function generateQwenCodeMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("qwencode", mcpServers, baseDir);
+}
+var init_qwencode = __esm({
+  "src/generators/mcp/qwencode.ts"() {
+    "use strict";
+    init_shared_factory();
+  }
+});
+
 // src/generators/mcp/roo.ts
 var roo_exports = {};
 __export(roo_exports, {
@@ -956,77 +1252,15 @@ __export(roo_exports, {
   generateRooMcpConfiguration: () => generateRooMcpConfiguration
 });
 function generateRooMcp(config) {
-  const rooConfig = {
-    mcpServers: {}
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldIncludeServer(server, "roo")) continue;
-    const rooServer = {};
-    if (server.command) {
-      rooServer.command = server.command;
-      if (server.args) rooServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        rooServer.url = url;
-      }
-      if (server.httpUrl || server.transport === "http") {
-        rooServer.type = "streamable-http";
-      } else if (server.transport === "sse" || server.type === "sse") {
-        rooServer.type = "sse";
-      }
-    }
-    if (server.env) {
-      rooServer.env = {};
-      for (const [key, value] of Object.entries(server.env)) {
-        if (value.startsWith("${env:") && value.endsWith("}")) {
-          rooServer.env[key] = value;
-        } else {
-          rooServer.env[key] = `\${env:${value}}`;
-        }
-      }
-    }
-    if (server.disabled !== void 0) {
-      rooServer.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      rooServer.alwaysAllow = server.alwaysAllow;
-    }
-    if (server.networkTimeout !== void 0) {
-      rooServer.networkTimeout = Math.max(3e4, Math.min(3e5, server.networkTimeout));
-    }
-    rooConfig.mcpServers[serverName] = rooServer;
-  }
-  return JSON.stringify(rooConfig, null, 2);
+  return generateMcpFromRegistry("roo", config);
 }
 function generateRooMcpConfiguration(mcpServers, baseDir = "") {
-  const filepath = baseDir ? `${baseDir}/.roo/mcp.json` : ".roo/mcp.json";
-  const config = {
-    mcpServers: {}
-  };
-  for (const [serverName, server] of Object.entries(mcpServers)) {
-    if (!shouldIncludeServer(server, "roo")) {
-      continue;
-    }
-    const { targets: _targets, ...serverConfig } = server;
-    const rooServer = { ...serverConfig };
-    if (serverConfig.httpUrl !== void 0 && serverConfig.url !== void 0) {
-      rooServer.url = serverConfig.httpUrl;
-    }
-    config.mcpServers[serverName] = rooServer;
-  }
-  return [
-    {
-      filepath,
-      content: `${JSON.stringify(config, null, 2)}
-`
-    }
-  ];
+  return generateMcpConfigurationFilesFromRegistry("roo", mcpServers, baseDir);
 }
 var init_roo = __esm({
   "src/generators/mcp/roo.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
@@ -1049,16 +1283,27 @@ var init_windsurf = __esm({
   }
 });
 
-// src/cli/index.ts
-var import_commander = require("commander");
-
-// src/cli/commands/add.ts
-var import_promises = require("fs/promises");
-var path = __toESM(require("path"), 1);
-
-// src/utils/config-loader.ts
-var import_c12 = require("c12");
-var import_core = require("zod/v4/core");
+// src/generators/mcp/opencode.ts
+var opencode_exports = {};
+__export(opencode_exports, {
+  generateOpenCodeMcp: () => generateOpenCodeMcp,
+  generateOpenCodeMcpConfiguration: () => generateOpenCodeMcpConfiguration
+});
+function generateOpenCodeMcp(config) {
+  return generateMcpFromRegistry("opencode", config);
+}
+function generateOpenCodeMcpConfiguration(mcpServers, baseDir = "") {
+  return generateMcpConfigurationFilesFromRegistry("opencode", mcpServers, baseDir);
+}
+var init_opencode = __esm({
+  "src/generators/mcp/opencode.ts"() {
+    "use strict";
+    init_shared_factory();
+  }
+});
+
+// src/cli/index.ts
+var import_commander = require("commander");
 
 // src/types/claudecode.ts
 var import_mini = require("zod/mini");
@@ -1103,6 +1348,7 @@ var ConfigSchema = import_mini4.z.object({
 var import_mini5 = require("zod/mini");
 init_tool_targets();
 var OutputPathsSchema = import_mini5.z.object({
+  amazonqcli: import_mini5.z.optional(import_mini5.z.string()),
   augmentcode: import_mini5.z.optional(import_mini5.z.string()),
   "augmentcode-legacy": import_mini5.z.optional(import_mini5.z.string()),
   copilot: import_mini5.z.optional(import_mini5.z.string()),
@@ -1110,6 +1356,8 @@ var OutputPathsSchema = import_mini5.z.object({
   cline: import_mini5.z.optional(import_mini5.z.string()),
   claudecode: import_mini5.z.optional(import_mini5.z.string()),
   codexcli: import_mini5.z.optional(import_mini5.z.string()),
+  opencode: import_mini5.z.optional(import_mini5.z.string()),
+  qwencode: import_mini5.z.optional(import_mini5.z.string()),
   roo: import_mini5.z.optional(import_mini5.z.string()),
   geminicli: import_mini5.z.optional(import_mini5.z.string()),
   kiro: import_mini5.z.optional(import_mini5.z.string()),
@@ -1161,7 +1409,7 @@ var import_mini6 = require("zod/mini");
 init_tool_targets();
 var McpTransportTypeSchema = import_mini6.z.enum(["stdio", "sse", "http"]);
 var McpServerBaseSchema = import_mini6.z.object({
-  command: import_mini6.z.optional(import_mini6.z.string()),
+  command: import_mini6.z.optional(import_mini6.z.union([import_mini6.z.string(), import_mini6.z.array(import_mini6.z.string())])),
   args: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
   url: import_mini6.z.optional(import_mini6.z.string()),
   httpUrl: import_mini6.z.optional(import_mini6.z.string()),
@@ -1211,12 +1459,21 @@ var GenerateOptionsSchema = import_mini7.z.object({
 // src/types/index.ts
 init_tool_targets();
 
+// src/cli/commands/add.ts
+var import_promises = require("fs/promises");
+var path = __toESM(require("path"), 1);
+
+// src/utils/config-loader.ts
+var import_c12 = require("c12");
+var import_core = require("zod/v4/core");
+
 // src/utils/config.ts
 init_tool_targets();
 function getDefaultConfig() {
   return {
     aiRulesDir: ".rulesync",
     outputPaths: {
+      amazonqcli: ".amazonq/rules",
       augmentcode: ".",
       "augmentcode-legacy": ".",
       copilot: ".github/instructions",
@@ -1224,6 +1481,8 @@ function getDefaultConfig() {
       cline: ".clinerules",
       claudecode: ".",
       codexcli: ".",
+      opencode: ".",
+      qwencode: ".qwen/memories",
       roo: ".roo/rules",
       geminicli: ".gemini/memories",
       kiro: ".kiro/steering",
@@ -1430,51 +1689,8 @@ 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
+init_logger();
 function sanitizeFilename(filename) {
   return filename.endsWith(".md") ? filename.slice(0, -3) : filename;
 }
@@ -1518,6 +1734,7 @@ var import_node_fs = require("fs");
 var import_node_path2 = __toESM(require("path"), 1);
 
 // src/utils/error.ts
+init_logger();
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -1547,90 +1764,11 @@ async function safeAsyncOperation(operation, errorContext) {
   }
 }
 
-// src/utils/file.ts
-var import_promises2 = require("fs/promises");
-var import_node_path = require("path");
-async function ensureDir(dirPath) {
-  try {
-    await (0, import_promises2.stat)(dirPath);
-  } catch {
-    await (0, import_promises2.mkdir)(dirPath, { recursive: true });
-  }
-}
-function resolvePath(relativePath, baseDir) {
-  return baseDir ? (0, import_node_path.join)(baseDir, relativePath) : relativePath;
-}
-async function readFileContent(filepath) {
-  return (0, import_promises2.readFile)(filepath, "utf-8");
-}
-async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path.dirname)(filepath));
-  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
-}
-async function fileExists(filepath) {
-  try {
-    await (0, import_promises2.stat)(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await (0, import_promises2.readdir)(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path.join)(dir, file));
-  } catch {
-    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 === "") {
-    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    logger.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await (0, import_promises2.rm)(filepath);
-    }
-  } catch (error) {
-    logger.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/index.ts
+init_file();
 
 // src/cli/commands/config.ts
+init_logger();
 async function configCommand(options = {}) {
   if (options.init) {
     await initConfig(options);
@@ -1841,25 +1979,25 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path13 = require("path");
+var import_node_path14 = require("path");
 
 // src/core/command-generator.ts
 var import_node_path5 = require("path");
 
 // src/utils/command-generators.ts
 var import_node_path3 = require("path");
-function generateYamlFrontmatter(command, options = {}) {
-  const frontmatter = ["---"];
-  if (options.includeDescription !== false && command.frontmatter.description) {
-    frontmatter.push(`description: ${command.frontmatter.description}`);
+function generateYamlFrontmatter(command, options) {
+  const frontmatterLines = ["---"];
+  if (options?.includeDescription && command.frontmatter.description) {
+    frontmatterLines.push(`description: ${command.frontmatter.description}`);
   }
-  if (options.additionalFields) {
+  if (options?.additionalFields) {
     for (const field of options.additionalFields) {
-      frontmatter.push(`${field.key}: ${field.value}`);
+      frontmatterLines.push(`${field.key}: ${field.value}`);
     }
   }
-  frontmatter.push("---");
-  return frontmatter;
+  frontmatterLines.push("---");
+  return frontmatterLines;
 }
 function buildCommandContent(command, frontmatterOptions) {
   const frontmatter = generateYamlFrontmatter(command, frontmatterOptions);
@@ -1898,26 +2036,75 @@ var syntaxConverters = {
   }
 };
 
-// src/generators/commands/claudecode.ts
-var ClaudeCodeCommandGenerator = class {
+// 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 = buildCommandContent(command);
+    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) {
-    return getFlattenedCommandPath(filename, baseDir, ".claude/commands");
+    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
-var GeminiCliCommandGenerator = class {
-  generate(command, outputDir) {
-    const filepath = this.getOutputPath(command.filename, outputDir);
+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) {
@@ -1925,32 +2112,28 @@ var GeminiCliCommandGenerator = class {
       tomlLines.push("");
     }
     tomlLines.push(`prompt = """${convertedContent}"""`);
-    const content = tomlLines.join("\n") + "\n";
-    return {
-      tool: "geminicli",
-      filepath,
-      content
-    };
+    return tomlLines.join("\n") + "\n";
   }
-  getOutputPath(filename, baseDir) {
-    return getHierarchicalCommandPath(filename, baseDir, ".gemini/commands", "toml");
+  supportsHierarchy() {
+    return true;
+  }
+  getFileExtension() {
+    return "toml";
   }
 };
 
 // src/generators/commands/roo.ts
-var RooCommandGenerator = class {
-  generate(command, outputDir) {
-    const filepath = this.getOutputPath(command.filename, outputDir);
-    const content = buildCommandContent(command);
-    return {
-      tool: "roo",
-      filepath,
-      content
-    };
+var RooCommandGenerator = class extends BaseCommandGenerator {
+  getToolName() {
+    return "roo";
   }
-  getOutputPath(filename, baseDir) {
-    return getFlattenedCommandPath(filename, baseDir, ".roo/commands");
+  getCommandsDirectory() {
+    return ".roo/commands";
+  }
+  processContent(command) {
+    return buildCommandContent(command, { includeDescription: true });
   }
+  // Uses flattened structure by default (supportsHierarchy returns false)
 };
 
 // src/generators/commands/index.ts
@@ -1963,6 +2146,10 @@ function getCommandGenerator(tool) {
   return commandGenerators[tool];
 }
 
+// src/core/command-generator.ts
+init_file();
+init_logger();
+
 // src/core/command-parser.ts
 var import_node_path4 = require("path");
 
@@ -1985,6 +2172,7 @@ function extractStringField(data, key, defaultValue) {
 }
 
 // src/core/command-parser.ts
+init_logger();
 async function parseCommandsFromDirectory(commandsDir) {
   const commandFiles = await findFiles(commandsDir, ".md");
   const commands = [];
@@ -2766,26 +2954,87 @@ async function generateKiroIgnoreFiles(rules, config, baseDir) {
   return generateIgnoreFile(rules, config, ignoreConfigs.kiro, baseDir);
 }
 
+// src/generators/ignore/qwencode.ts
+var import_node_path7 = require("path");
+function extractQwenCodeFileFilteringPatterns(content) {
+  const filtering = {};
+  const configBlocks = content.match(/```(?:json|javascript)\s*\n([\s\S]*?)\n```/g);
+  if (configBlocks) {
+    for (const block of configBlocks) {
+      try {
+        const jsonContent = block.replace(/```(?:json|javascript)\s*\n/, "").replace(/\n```$/, "");
+        const parsed = JSON.parse(jsonContent);
+        if (parsed.fileFiltering) {
+          Object.assign(filtering, parsed.fileFiltering);
+        }
+      } catch {
+      }
+    }
+  }
+  if (content.includes("respectGitIgnore")) {
+    if (content.includes("respectGitIgnore: false") || content.includes('"respectGitIgnore": false')) {
+      filtering.respectGitIgnore = false;
+    } else {
+      filtering.respectGitIgnore = true;
+    }
+  }
+  if (content.includes("enableRecursiveFileSearch")) {
+    if (content.includes("enableRecursiveFileSearch: false") || content.includes('"enableRecursiveFileSearch": false')) {
+      filtering.enableRecursiveFileSearch = false;
+    } else {
+      filtering.enableRecursiveFileSearch = true;
+    }
+  }
+  return Object.keys(filtering).length > 0 ? filtering : void 0;
+}
+function generateQwenCodeConfiguration(rules) {
+  const config = {};
+  config.fileFiltering = {
+    respectGitIgnore: true,
+    enableRecursiveFileSearch: true
+  };
+  for (const rule of rules) {
+    const ruleFiltering = extractQwenCodeFileFilteringPatterns(rule.content);
+    if (ruleFiltering) {
+      Object.assign(config.fileFiltering, ruleFiltering);
+    }
+  }
+  return config;
+}
+async function generateQwenCodeIgnoreFiles(rules, config, baseDir) {
+  const outputs = [];
+  const outputPath = baseDir || process.cwd();
+  const qwenConfig = generateQwenCodeConfiguration(rules);
+  const settingsPath = (0, import_node_path7.join)(outputPath, ".qwen", "settings.json");
+  outputs.push({
+    tool: "qwencode",
+    filepath: settingsPath,
+    content: `${JSON.stringify(qwenConfig, null, 2)}
+`
+  });
+  return outputs;
+}
+
 // src/generators/ignore/windsurf.ts
 function generateWindsurfIgnore(rules, config, baseDir) {
   return generateIgnoreFile(rules, config, ignoreConfigs.windsurf, baseDir);
 }
 
-// src/generators/rules/augmentcode.ts
-var import_node_path9 = require("path");
-
 // src/generators/rules/shared-helpers.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
+init_file();
 
 // src/utils/ignore.ts
-var import_node_path7 = require("path");
+var import_node_path8 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
+init_file();
+init_logger();
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path7.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path8.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -2839,7 +3088,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: (0, import_node_path8.join)(outputDir, relativePath),
+    filepath: (0, import_node_path9.join)(outputDir, relativePath),
     content
   });
 }
@@ -2848,7 +3097,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_path8.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path9.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -2876,7 +3125,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        (0, import_node_path8.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        (0, import_node_path9.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -2930,7 +3179,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
+var import_node_path10 = require("path");
 async function generateAugmentcodeConfig(rules, config, baseDir) {
   const outputs = createOutputsArray();
   rules.forEach((rule) => {
@@ -2939,13 +3242,13 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      (0, import_node_path9.join)(".augment", "rules", `${rule.filename}.md`),
-      generateRuleFile(rule)
+      (0, import_node_path10.join)(".augment", "rules", `${rule.filename}.md`),
+      generateRuleFile2(rule)
     );
   });
   return outputs;
 }
-function generateRuleFile(rule) {
+function generateRuleFile2(rule) {
   const lines = [];
   lines.push("---");
   let ruleType = "manual";
@@ -2992,7 +3295,9 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path10 = require("path");
+var import_node_path11 = require("path");
+init_file();
+init_logger();
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const generatorConfig = {
     tool: "claudecode",
@@ -3004,7 +3309,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
     updateAdditionalConfig: async (ignorePatterns, baseDir2) => {
-      const settingsPath = resolvePath((0, import_node_path10.join)(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath((0, import_node_path11.join)(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -3068,7 +3373,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/generator-registry.ts
-var import_node_path11 = require("path");
+var import_node_path12 = require("path");
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -3092,6 +3397,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",
@@ -3148,7 +3469,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return (0, import_node_path11.join)(outputDir, `${baseFilename}.instructions.md`);
+      return (0, import_node_path12.join)(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -3188,7 +3509,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return (0, import_node_path11.join)(outputDir, `${rule.filename}.mdc`);
+      return (0, import_node_path12.join)(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -3224,10 +3545,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return (0, import_node_path11.join)(outputDir, ".windsurf-rules");
+        return (0, import_node_path12.join)(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = (0, import_node_path11.join)(outputDir, ".windsurf", "rules");
-        return (0, import_node_path11.join)(rulesDir, `${rule.filename}.md`);
+        const rulesDir = (0, import_node_path12.join)(outputDir, ".windsurf", "rules");
+        return (0, import_node_path12.join)(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -3258,6 +3579,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());
@@ -3280,7 +3617,23 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     }
     // Complex generation handled by existing generator
-  }
+  },
+  qwencode: {
+    type: "complex",
+    tool: "qwencode",
+    fileExtension: ".md",
+    // ignoreFileName omitted - Qwen Code uses git-aware filtering instead of dedicated ignore files
+    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
+  }
 };
 async function generateFromRegistry(tool, rules, config, baseDir) {
   const generatorConfig = GENERATOR_REGISTRY[tool];
@@ -3300,8 +3653,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
       },
@@ -3330,50 +3683,94 @@ var generateCopilotConfig = createSimpleGenerator("copilot");
 var generateWindsurfConfig = createSimpleGenerator("windsurf");
 var generateKiroConfig = createSimpleGenerator("kiro");
 var generateRooConfig = createSimpleGenerator("roo");
+var generateQwencodeConfig = createSimpleGenerator("qwencode");
 
 // 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}/AGENTS.md`;
-    outputs.push({
-      tool: "codexcli",
-      filepath,
-      content: concatenatedContent
+init_file();
+
+// src/utils/xml-document-generator.ts
+var import_fast_xml_parser = require("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 import_fast_xml_parser.XMLBuilder({
+      format: true,
+      ignoreAttributes: false,
+      suppressEmptyNode: false
     });
+    const xmlContent = builder.build(documentsData);
+    lines.push(xmlContent);
+    lines.push("");
+    lines.push("");
   }
-  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
-    });
+  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 outputs;
+  return lines.join("\n");
 }
-function generateConcatenatedCodexContent(rules) {
-  const sections = [];
-  for (const rule of rules) {
-    const content = rule.content.trim();
-    if (!content) {
-      continue;
+
+// src/generators/rules/codexcli.ts
+async function generateCodexConfig(rules, config, baseDir) {
+  const outputs = [];
+  const nonEmptyRules = rules.filter((rule) => rule.content.trim().length > 0);
+  if (nonEmptyRules.length > 0) {
+    const generatorConfig = {
+      tool: "codexcli",
+      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
+      });
     }
-    sections.push(content);
   }
-  return sections.join("\n\n---\n\n");
+  return outputs;
+}
+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
@@ -3394,28 +3791,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
@@ -3445,7 +3824,56 @@ 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/generators/rules/qwencode.ts
+async function generateQwencodeConfig2(rules, config, baseDir) {
+  const generatorConfig = {
+    tool: "qwencode",
+    fileExtension: ".md",
+    // ignoreFileName omitted - Qwen Code uses git-aware filtering instead of dedicated ignore files
+    generateContent: generateQwenMemoryMarkdown,
+    generateDetailContent: generateQwenMemoryMarkdown,
+    generateRootContent: generateQwenRootMarkdown,
+    rootFilePath: "QWEN.md",
+    detailSubDir: ".qwen/memories"
+  };
+  return generateComplexRules(rules, config, generatorConfig, baseDir);
+}
+function generateQwenMemoryMarkdown(rule) {
+  return rule.content.trim();
+}
+function generateQwenRootMarkdown(rootRule, memoryRules, _baseDir) {
+  return generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
+    memorySubDir: ".qwen/memories",
+    fallbackTitle: "Qwen Code Configuration"
+  });
+}
+
 // src/core/generator.ts
+init_logger();
 async function generateConfigurations(rules, config, targetTools, baseDir) {
   const outputs = createOutputsArray();
   const toolsToGenerate = targetTools || config.defaultTargets;
@@ -3477,6 +3905,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);
@@ -3515,6 +3945,13 @@ 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 "qwencode": {
+      const qwenRulesOutputs = await generateQwencodeConfig2(rules, config, baseDir);
+      const qwenIgnoreOutputs = await generateQwenCodeIgnoreFiles(rules, config, baseDir);
+      return [...qwenRulesOutputs, ...qwenIgnoreOutputs];
+    }
     case "windsurf": {
       const windsurfRulesOutputs = await generateWindsurfConfig(rules, config, baseDir);
       const windsurfIgnoreOutputs = await generateWindsurfIgnore(rules, config, baseDir);
@@ -3527,7 +3964,8 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
+init_logger();
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const allRuleFiles = await findRuleFiles(aiRulesDir);
@@ -3580,7 +4018,7 @@ async function parseRuleFile(filepath) {
       },
       ...validatedData.tags !== void 0 && { tags: validatedData.tags }
     };
-    const filename = (0, import_node_path12.basename)(filepath, ".md");
+    const filename = (0, import_node_path13.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -3648,6 +4086,7 @@ async function validateRule(rule) {
 var path4 = __toESM(require("path"), 1);
 
 // src/generators/mcp/index.ts
+init_amazonqcli();
 init_augmentcode();
 init_claudecode();
 init_cline();
@@ -3657,9 +4096,13 @@ init_cursor();
 init_geminicli();
 init_junie();
 init_kiro();
+init_qwencode();
 init_roo();
 init_windsurf();
 
+// src/core/mcp-generator.ts
+init_file();
+
 // src/core/mcp-parser.ts
 var fs = __toESM(require("fs"), 1);
 var path3 = __toESM(require("path"), 1);
@@ -3691,6 +4134,36 @@ function parseMcpConfig(projectRoot) {
 async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
   const outputs = [];
   const toolMap = {
+    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: ".",
+          qwencode: ".qwen/memories",
+          roo: ".roo/rules",
+          geminicli: ".gemini/memories",
+          kiro: ".kiro/steering",
+          junie: ".",
+          windsurf: "."
+        },
+        watchEnabled: false,
+        defaultTargets: []
+      };
+      const results = await (await Promise.resolve().then(() => (init_amazonqcli(), amazonqcli_exports))).generateAmazonqcliMcp(
+        servers,
+        config,
+        dir
+      );
+      return results.map((result) => ({ filepath: result.filepath, content: result.content }));
+    },
     augmentcode: async (servers, dir) => (await Promise.resolve().then(() => (init_augmentcode(), augmentcode_exports))).generateAugmentcodeMcpConfiguration(
       servers,
       dir
@@ -3707,6 +4180,10 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
     cursor: async (servers, dir) => (await Promise.resolve().then(() => (init_cursor(), cursor_exports))).generateCursorMcpConfiguration(servers, dir),
     cline: async (servers, dir) => (await Promise.resolve().then(() => (init_cline(), cline_exports))).generateClineMcpConfiguration(servers, dir),
     codexcli: async (servers, dir) => (await Promise.resolve().then(() => (init_codexcli(), codexcli_exports))).generateCodexMcpConfiguration(servers, dir),
+    opencode: async (servers, dir) => (await Promise.resolve().then(() => (init_opencode(), opencode_exports))).generateOpenCodeMcpConfiguration(
+      servers,
+      dir
+    ),
     roo: async (servers, dir) => (await Promise.resolve().then(() => (init_roo(), roo_exports))).generateRooMcpConfiguration(servers, dir),
     geminicli: async (servers, dir) => (await Promise.resolve().then(() => (init_geminicli(), geminicli_exports))).generateGeminiCliMcpConfiguration(
       servers,
@@ -3714,6 +4191,10 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
     ),
     kiro: async (servers, dir) => (await Promise.resolve().then(() => (init_kiro(), kiro_exports))).generateKiroMcpConfiguration(servers, dir),
     junie: async (servers, dir) => (await Promise.resolve().then(() => (init_junie(), junie_exports))).generateJunieMcpConfiguration(servers, dir),
+    qwencode: async (servers, dir) => (await Promise.resolve().then(() => (init_qwencode(), qwencode_exports))).generateQwenCodeMcpConfiguration(
+      servers,
+      dir
+    ),
     windsurf: async (servers, dir) => (await Promise.resolve().then(() => (init_windsurf(), windsurf_exports))).generateWindsurfMcpConfiguration(
       servers,
       dir
@@ -3736,6 +4217,7 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
 }
 
 // src/cli/commands/generate.ts
+init_logger();
 async function generateCommand(options = {}) {
   const configLoaderOptions = {
     ...options.config !== void 0 && { configPath: options.config },
@@ -3743,35 +4225,40 @@ async function generateCommand(options = {}) {
   };
   const configResult = await loadConfig(configLoaderOptions);
   const cliOptions = {
-    ...options.tools !== void 0 && { tools: options.tools },
+    tools: options.tools,
     ...options.verbose !== void 0 && { verbose: options.verbose },
     ...options.delete !== void 0 && { delete: options.delete },
     ...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;
-    const cliToolsSet = new Set(cliTools);
-    const configTargetsSet = new Set(configTargets);
-    const notInConfig = cliTools.filter((tool) => !configTargetsSet.has(tool));
-    const notInCli = configTargets.filter((tool) => !cliToolsSet.has(tool));
-    if (notInConfig.length > 0 || notInCli.length > 0) {
-      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) {
-        logger.warn(`   Tools specified but not in config: ${notInConfig.join(", ")}`);
-      }
-      if (notInCli.length > 0) {
-        logger.warn(`   Tools in config but not specified: ${notInCli.join(", ")}`);
-      }
-      logger.warn("\n   The configuration file targets will be used.");
-      logger.warn("   To change targets, update your rulesync config file.");
-      logger.warn("");
-    }
+  if (!config.defaultTargets || config.defaultTargets.length === 0) {
+    const errorMessage = `\u274C Error: At least one tool must be specified.
+
+Available tools:
+  --augmentcode         Generate for AugmentCode
+  --augmentcode-legacy  Generate for AugmentCode legacy format
+  --copilot             Generate for GitHub Copilot
+  --cursor              Generate for Cursor
+  --cline               Generate for Cline
+  --codexcli            Generate for OpenAI Codex CLI
+  --claudecode          Generate for Claude Code
+  --roo                 Generate for Roo Code
+  --geminicli           Generate for Gemini CLI
+  --junie               Generate for JetBrains Junie
+  --qwencode            Generate for Qwen Code
+  --kiro                Generate for Kiro IDE
+  --opencode            Generate for OpenCode
+  --windsurf            Generate for Windsurf
+
+Example:
+  rulesync generate --copilot --cursor
+
+Or specify tools in rulesync.jsonc:
+  "tools": ["copilot", "cursor"]`;
+    logger.error(errorMessage);
+    process.exit(1);
   }
+  logger.setVerbose(config.verbose || false);
   let baseDirs;
   if (config.baseDir) {
     baseDirs = Array.isArray(config.baseDir) ? config.baseDir : [config.baseDir];
@@ -3799,7 +4286,7 @@ async function generateCommand(options = {}) {
       logger.info("Deleting existing output directories...");
       const targetTools = config.defaultTargets;
       const deleteTasks = [];
-      const commandsDir = (0, import_node_path13.join)(config.aiRulesDir, "commands");
+      const commandsDir = (0, import_node_path14.join)(config.aiRulesDir, "commands");
       const hasCommands = await fileExists(commandsDir);
       let hasCommandFiles = false;
       if (hasCommands) {
@@ -3814,12 +4301,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "rules")));
-            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "rules")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -3833,24 +4320,30 @@ async function generateCommand(options = {}) {
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".claude", "commands")));
+              deleteTasks.push(removeDirectory((0, import_node_path14.join)(".claude", "commands")));
             }
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".roo", "commands")));
+              deleteTasks.push(removeDirectory((0, import_node_path14.join)(".roo", "commands")));
             }
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
             if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".gemini", "commands")));
+              deleteTasks.push(removeDirectory((0, import_node_path14.join)(".gemini", "commands")));
             }
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
             break;
+          case "opencode":
+            deleteTasks.push(removeDirectory(config.outputPaths.opencode));
+            break;
+          case "qwencode":
+            deleteTasks.push(removeDirectory(config.outputPaths.qwencode));
+            break;
           case "windsurf":
             deleteTasks.push(removeDirectory(config.outputPaths.windsurf));
             break;
@@ -3944,11 +4437,14 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path15 = require("path");
+init_logger();
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path14.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path15.join)(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/",
@@ -3966,6 +4462,8 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
+    "**/QWEN.md",
+    "**/.qwen/memories/",
     "**/.aiexclude",
     "**/.aiignore",
     "**/.augmentignore",
@@ -3974,6 +4472,9 @@ var gitignoreCommand = async () => {
     "**/.augment-guidelines",
     "**/.junie/guidelines.md",
     "**/.noai",
+    "**/.opencode/memories/",
+    "**/.opencode/commands/",
+    "**/opencode.json",
     "**/.mcp.json",
     "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
@@ -3981,193 +4482,44 @@ var gitignoreCommand = async () => {
     "**/.vscode/mcp.json",
     "**/.codex/mcp-config.json",
     "**/.gemini/settings.json",
+    "**/.qwen/settings.json",
     "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
-  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
-    gitignoreContent = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
-  }
-  const linesToAdd = [];
-  for (const rule of rulesFilesToIgnore) {
-    if (!gitignoreContent.includes(rule)) {
-      linesToAdd.push(rule);
-    }
-  }
-  if (linesToAdd.length === 0) {
-    logger.success(".gitignore is already up to date");
-    return;
-  }
-  const newContent = gitignoreContent ? `${gitignoreContent.trimEnd()}
-
-${linesToAdd.join("\n")}
-` : `${linesToAdd.join("\n")}
-`;
-  (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
-  logger.success(`Added ${linesToAdd.length} rules to .gitignore:`);
-  for (const line of linesToAdd) {
-    if (!line.startsWith("#")) {
-      logger.log(`  ${line}`);
-    }
-  }
-};
-
-// src/core/importer.ts
-var import_node_path21 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
-
-// src/parsers/augmentcode.ts
-var import_node_path15 = require("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 = (0, import_node_path15.join)(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 = (0, import_node_path15.join)(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 = (0, import_node_path15.join)(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 = (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.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}`);
-        }
-      }
+  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
+    gitignoreContent = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
+  }
+  const linesToAdd = [];
+  for (const rule of rulesFilesToIgnore) {
+    if (!gitignoreContent.includes(rule)) {
+      linesToAdd.push(rule);
     }
-  } 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"] };
+  if (linesToAdd.length === 0) {
+    logger.success(".gitignore is already up to date");
+    return;
   }
-}
+  const newContent = gitignoreContent ? `${gitignoreContent.trimEnd()}
+
+${linesToAdd.join("\n")}
+` : `${linesToAdd.join("\n")}
+`;
+  (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
+  logger.success(`Added ${linesToAdd.length} rules to .gitignore:`);
+  for (const line of linesToAdd) {
+    if (!line.startsWith("#")) {
+      logger.log(`  ${line}`);
+    }
+  }
+};
+
+// src/core/importer.ts
+var import_node_path22 = require("path");
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/shared-helpers.ts
 var import_node_path16 = require("path");
+init_file();
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
@@ -4483,6 +4835,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
+var import_node_path17 = require("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 = (0, import_node_path17.join)(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 = (0, import_node_path17.join)(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 = (0, import_node_path17.join)(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 = (0, import_node_path17.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.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, {
@@ -4518,7 +5034,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -4541,7 +5057,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_js_yaml = require("js-yaml");
 var import_mini8 = require("zod/mini");
 var customMatterOptions = {
@@ -4665,7 +5181,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path18.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path19.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -4686,20 +5202,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path18.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path19.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_path18.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path19.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = parseFrontmatter(rawContent, { matterOptions: customMatterOptions });
             const content = parsed.content;
             if (content) {
-              const filename = (0, import_node_path18.basename)(file, ".mdc");
+              const filename = (0, import_node_path19.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -4722,7 +5238,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_path18.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path19.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -4735,7 +5251,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path18.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path19.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -4785,11 +5301,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = (0, import_node_path19.join)(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = (0, import_node_path20.join)(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -4820,6 +5336,48 @@ 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/qwencode.ts
+async function parseQwenConfiguration(baseDir = process.cwd()) {
+  return parseMemoryBasedConfiguration(baseDir, {
+    tool: "qwencode",
+    mainFileName: "QWEN.md",
+    memoryDirPath: ".qwen/memories",
+    settingsPath: ".qwen/settings.json",
+    mainDescription: "Main Qwen Code configuration",
+    memoryDescription: "Memory file",
+    filenamePrefix: "qwen",
+    // Qwen Code uses git-aware filtering instead of dedicated ignore files
+    // additionalIgnoreFile is omitted
+    commandsDirPath: ".qwen/commands"
+  });
+}
+
 // src/parsers/roo.ts
 async function parseRooConfiguration(baseDir = process.cwd()) {
   return parseConfigurationFiles(baseDir, {
@@ -4842,9 +5400,11 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 
 // src/parsers/windsurf.ts
 var import_promises3 = require("fs/promises");
-var import_node_path20 = require("path");
+var import_node_path21 = require("path");
+init_logger();
 
 // src/core/importer.ts
+init_logger();
 async function importConfiguration(options) {
   const {
     tool,
@@ -4862,6 +5422,13 @@ async function importConfiguration(options) {
   }
   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;
@@ -4922,6 +5489,21 @@ 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;
+      }
+      case "qwencode": {
+        const qwenResult = await parseQwenConfiguration(baseDir);
+        rules = qwenResult.rules;
+        errors.push(...qwenResult.errors);
+        mcpServers = qwenResult.mcpServers;
+        break;
+      }
       default:
         errors.push(`Unsupported tool: ${tool}`);
         return { success: false, rulesCreated: 0, errors };
@@ -4934,7 +5516,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path21.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path22.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -4949,17 +5531,17 @@ async function importConfiguration(options) {
       const baseFilename = rule.filename;
       let targetDir = rulesDirPath;
       if (rule.type === "command") {
-        targetDir = (0, import_node_path21.join)(rulesDirPath, "commands");
+        targetDir = (0, import_node_path22.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");
+          targetDir = (0, import_node_path22.join)(rulesDirPath, "rules");
           const { mkdir: mkdir3 } = await import("fs/promises");
           await mkdir3(targetDir, { recursive: true });
         }
       }
-      const filePath = (0, import_node_path21.join)(targetDir, `${baseFilename}.md`);
+      const filePath = (0, import_node_path22.join)(targetDir, `${baseFilename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -4974,7 +5556,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path21.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path22.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -4990,7 +5572,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path21.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path22.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -5025,9 +5607,11 @@ function generateRuleFileContent(rule) {
 }
 
 // src/cli/commands/import.ts
+init_logger();
 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");
@@ -5036,9 +5620,11 @@ async function importCommand(options = {}) {
   if (options.cline) tools.push("cline");
   if (options.roo) tools.push("roo");
   if (options.geminicli) tools.push("geminicli");
+  if (options.qwencode) tools.push("qwencode");
+  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, --qwencode, --opencode)"
     );
     process.exit(1);
   }
@@ -5086,7 +5672,8 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path22 = require("path");
+var import_node_path23 = require("path");
+init_logger();
 async function initCommand(options = {}) {
   const configResult = await loadConfig();
   const config = configResult.config;
@@ -5094,7 +5681,7 @@ async function initCommand(options = {}) {
   logger.log("Initializing rulesync...");
   await ensureDir(aiRulesDir);
   const useLegacy = options.legacy ?? config.legacy ?? false;
-  const rulesDir = useLegacy ? aiRulesDir : (0, import_node_path22.join)(aiRulesDir, "rules");
+  const rulesDir = useLegacy ? aiRulesDir : (0, import_node_path23.join)(aiRulesDir, "rules");
   if (!useLegacy) {
     await ensureDir(rulesDir);
   }
@@ -5140,7 +5727,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path22.join)(rulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path23.join)(rulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     logger.success(`Created ${filepath}`);
@@ -5150,6 +5737,7 @@ globs: ["**/*"]
 }
 
 // src/cli/commands/status.ts
+init_logger();
 async function statusCommand() {
   const config = getDefaultConfig();
   logger.log("rulesync Status");
@@ -5202,6 +5790,7 @@ async function statusCommand() {
 }
 
 // src/cli/commands/validate.ts
+init_logger();
 async function validateCommand() {
   const config = getDefaultConfig();
   logger.log("Validating rulesync configuration...");
@@ -5244,6 +5833,7 @@ Validation failed with ${validation.errors.length} error(s)`);
 
 // src/cli/commands/watch.ts
 var import_chokidar = require("chokidar");
+init_logger();
 async function watchCommand() {
   const config = getDefaultConfig();
   logger.log("\u{1F440} Watching for changes in .rulesync directory...");
@@ -5284,37 +5874,41 @@ 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.63.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.65.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("--qwencode", "Import from Qwen Code (QWEN.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("--all", "Generate for all supported 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("--qwencode", "Generate only for Qwen Code").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) => {
   const tools = [];
-  if (options.augmentcode) tools.push("augmentcode");
-  if (options["augmentcode-legacy"]) tools.push("augmentcode-legacy");
-  if (options.copilot) tools.push("copilot");
-  if (options.cursor) tools.push("cursor");
-  if (options.cline) tools.push("cline");
-  if (options.codexcli) tools.push("codexcli");
-  if (options.claudecode) tools.push("claudecode");
-  if (options.roo) tools.push("roo");
-  if (options.geminicli) tools.push("geminicli");
-  if (options.junie) tools.push("junie");
-  if (options.kiro) tools.push("kiro");
-  if (options.windsurf) tools.push("windsurf");
+  if (options.all) {
+    tools.push(...ALL_TOOL_TARGETS);
+  } else {
+    if (options.augmentcode) tools.push("augmentcode");
+    if (options["augmentcode-legacy"]) tools.push("augmentcode-legacy");
+    if (options.copilot) tools.push("copilot");
+    if (options.cursor) tools.push("cursor");
+    if (options.cline) tools.push("cline");
+    if (options.codexcli) tools.push("codexcli");
+    if (options.claudecode) tools.push("claudecode");
+    if (options.roo) tools.push("roo");
+    if (options.geminicli) tools.push("geminicli");
+    if (options.junie) tools.push("junie");
+    if (options.qwencode) tools.push("qwencode");
+    if (options.kiro) tools.push("kiro");
+    if (options.opencode) tools.push("opencode");
+    if (options.windsurf) tools.push("windsurf");
+  }
   const generateOptions = {
     verbose: options.verbose,
+    tools: tools.length > 0 ? tools : void 0,
     delete: options.delete,
     config: options.config,
     noConfig: options.noConfig
   };
-  if (tools.length > 0) {
-    generateOptions.tools = tools;
-  }
   if (options.baseDir) {
     generateOptions.baseDirs = options.baseDir.split(",").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
   }