rulesync 0.64.0 → 0.67.0

package/dist/index.cjs

@@ -35,12 +35,13 @@ function isToolTarget(target) {
   if (!target) return false;
   return ALL_TOOL_TARGETS.some((validTarget) => validTarget === target);
 }
-var import_mini2, ALL_TOOL_TARGETS, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
+var import_mini, ALL_TOOL_TARGETS, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
 var init_tool_targets = __esm({
   "src/types/tool-targets.ts"() {
     "use strict";
-    import_mini2 = require("zod/mini");
+    import_mini = require("zod/mini");
     ALL_TOOL_TARGETS = [
+      "agentsmd",
       "amazonqcli",
       "augmentcode",
       "augmentcode-legacy",
@@ -50,16 +51,17 @@ var init_tool_targets = __esm({
       "claudecode",
       "codexcli",
       "opencode",
+      "qwencode",
       "roo",
       "geminicli",
       "kiro",
       "junie",
       "windsurf"
     ];
-    ToolTargetSchema = import_mini2.z.enum(ALL_TOOL_TARGETS);
-    ToolTargetsSchema = import_mini2.z.array(ToolTargetSchema);
-    WildcardTargetSchema = import_mini2.z.tuple([import_mini2.z.literal("*")]);
-    RulesyncTargetsSchema = import_mini2.z.union([ToolTargetsSchema, WildcardTargetSchema]);
+    ToolTargetSchema = import_mini.z.enum(ALL_TOOL_TARGETS);
+    ToolTargetsSchema = import_mini.z.array(ToolTargetSchema);
+    WildcardTargetSchema = import_mini.z.tuple([import_mini.z.literal("*")]);
+    RulesyncTargetsSchema = import_mini.z.union([ToolTargetsSchema, WildcardTargetSchema]);
   }
 });
 
@@ -161,8 +163,8 @@ async function findRuleFiles(aiRulesDir) {
     newLocationFiles.map((file) => file.split("/").pop()?.replace(/\.md$/, ""))
   );
   const filteredLegacyFiles = legacyLocationFiles.filter((file) => {
-    const basename6 = file.split("/").pop()?.replace(/\.md$/, "");
-    return !newLocationBasenames.has(basename6);
+    const basename7 = file.split("/").pop()?.replace(/\.md$/, "");
+    return !newLocationBasenames.has(basename7);
   });
   return [...newLocationFiles, ...filteredLegacyFiles];
 }
@@ -796,6 +798,19 @@ var init_shared_factory = __esm({
           $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");
@@ -1212,6 +1227,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, {
@@ -1272,6 +1306,75 @@ var init_opencode = __esm({
 // src/cli/index.ts
 var import_commander = require("commander");
 
+// src/types/config-options.ts
+var import_mini2 = require("zod/mini");
+init_tool_targets();
+var FEATURE_TYPES = ["rules", "commands", "mcp", "ignore", "subagents"];
+var FeatureTypeSchema = import_mini2.z.enum(FEATURE_TYPES);
+var FeaturesSchema = import_mini2.z.union([import_mini2.z.array(FeatureTypeSchema), import_mini2.z.literal("*")]);
+var OutputPathsSchema = import_mini2.z.object({
+  agentsmd: import_mini2.z.optional(import_mini2.z.string()),
+  amazonqcli: import_mini2.z.optional(import_mini2.z.string()),
+  augmentcode: import_mini2.z.optional(import_mini2.z.string()),
+  "augmentcode-legacy": import_mini2.z.optional(import_mini2.z.string()),
+  copilot: import_mini2.z.optional(import_mini2.z.string()),
+  cursor: import_mini2.z.optional(import_mini2.z.string()),
+  cline: import_mini2.z.optional(import_mini2.z.string()),
+  claudecode: import_mini2.z.optional(import_mini2.z.string()),
+  codexcli: import_mini2.z.optional(import_mini2.z.string()),
+  opencode: import_mini2.z.optional(import_mini2.z.string()),
+  qwencode: import_mini2.z.optional(import_mini2.z.string()),
+  roo: import_mini2.z.optional(import_mini2.z.string()),
+  geminicli: import_mini2.z.optional(import_mini2.z.string()),
+  kiro: import_mini2.z.optional(import_mini2.z.string()),
+  junie: import_mini2.z.optional(import_mini2.z.string()),
+  windsurf: import_mini2.z.optional(import_mini2.z.string())
+});
+var ConfigOptionsSchema = import_mini2.z.object({
+  aiRulesDir: import_mini2.z.optional(import_mini2.z.string()),
+  outputPaths: import_mini2.z.optional(OutputPathsSchema),
+  watchEnabled: import_mini2.z.optional(import_mini2.z.boolean()),
+  defaultTargets: import_mini2.z.optional(ToolTargetsSchema),
+  targets: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
+  exclude: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
+  features: import_mini2.z.optional(FeaturesSchema),
+  verbose: import_mini2.z.optional(import_mini2.z.boolean()),
+  delete: import_mini2.z.optional(import_mini2.z.boolean()),
+  baseDir: import_mini2.z.optional(import_mini2.z.union([import_mini2.z.string(), import_mini2.z.array(import_mini2.z.string())])),
+  legacy: import_mini2.z.optional(import_mini2.z.boolean()),
+  watch: import_mini2.z.optional(
+    import_mini2.z.object({
+      enabled: import_mini2.z.optional(import_mini2.z.boolean()),
+      interval: import_mini2.z.optional(import_mini2.z.number()),
+      ignore: import_mini2.z.optional(import_mini2.z.array(import_mini2.z.string()))
+    })
+  )
+});
+var MergedConfigSchema = import_mini2.z.object({
+  aiRulesDir: import_mini2.z.string(),
+  outputPaths: import_mini2.z.record(ToolTargetSchema, import_mini2.z.string()),
+  watchEnabled: import_mini2.z.boolean(),
+  defaultTargets: ToolTargetsSchema,
+  targets: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
+  exclude: import_mini2.z.optional(import_mini2.z.array(ToolTargetSchema)),
+  features: import_mini2.z.optional(FeaturesSchema),
+  verbose: import_mini2.z.optional(import_mini2.z.boolean()),
+  delete: import_mini2.z.optional(import_mini2.z.boolean()),
+  baseDir: import_mini2.z.optional(import_mini2.z.union([import_mini2.z.string(), import_mini2.z.array(import_mini2.z.string())])),
+  configPath: import_mini2.z.optional(import_mini2.z.string()),
+  legacy: import_mini2.z.optional(import_mini2.z.boolean()),
+  watch: import_mini2.z.optional(
+    import_mini2.z.object({
+      enabled: import_mini2.z.optional(import_mini2.z.boolean()),
+      interval: import_mini2.z.optional(import_mini2.z.number()),
+      ignore: import_mini2.z.optional(import_mini2.z.array(import_mini2.z.string()))
+    })
+  )
+});
+
+// src/cli/index.ts
+init_logger();
+
 // src/cli/commands/add.ts
 var import_promises = require("fs/promises");
 var path = __toESM(require("path"), 1);
@@ -1281,101 +1384,42 @@ var import_c12 = require("c12");
 var import_core = require("zod/v4/core");
 
 // src/types/claudecode.ts
-var import_mini = require("zod/mini");
-var ClaudeSettingsSchema = import_mini.z.looseObject({
-  permissions: import_mini.z._default(
-    import_mini.z.looseObject({
-      deny: import_mini.z._default(import_mini.z.array(import_mini.z.string()), [])
+var import_mini3 = require("zod/mini");
+var ClaudeSettingsSchema = import_mini3.z.looseObject({
+  permissions: import_mini3.z._default(
+    import_mini3.z.looseObject({
+      deny: import_mini3.z._default(import_mini3.z.array(import_mini3.z.string()), [])
     }),
     { deny: [] }
   )
 });
 
 // src/types/shared.ts
-var import_mini3 = require("zod/mini");
+var import_mini4 = require("zod/mini");
 init_tool_targets();
-var OutputSchema = import_mini3.z.object({
+var OutputSchema = import_mini4.z.object({
   tool: ToolTargetSchema,
-  filepath: import_mini3.z.string(),
-  content: import_mini3.z.string()
+  filepath: import_mini4.z.string(),
+  content: import_mini4.z.string()
 });
-var BaseFrontmatterSchema = import_mini3.z.object({
-  description: import_mini3.z.optional(import_mini3.z.string())
+var BaseFrontmatterSchema = import_mini4.z.object({
+  description: import_mini4.z.optional(import_mini4.z.string())
 });
 
 // src/types/commands.ts
 var CommandFrontmatterSchema = BaseFrontmatterSchema;
 
 // src/types/config.ts
-var import_mini4 = require("zod/mini");
-init_tool_targets();
-var ConfigSchema = import_mini4.z.object({
-  aiRulesDir: import_mini4.z.string(),
-  outputPaths: import_mini4.z.record(ToolTargetSchema, import_mini4.z.string()),
-  watchEnabled: import_mini4.z.boolean(),
-  defaultTargets: ToolTargetsSchema,
-  claudecodeCommands: import_mini4.z.optional(import_mini4.z.string()),
-  geminicliCommands: import_mini4.z.optional(import_mini4.z.string()),
-  legacy: import_mini4.z.optional(import_mini4.z.boolean())
-});
-
-// src/types/config-options.ts
 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()),
-  cursor: import_mini5.z.optional(import_mini5.z.string()),
-  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()),
-  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()),
-  junie: import_mini5.z.optional(import_mini5.z.string()),
-  windsurf: import_mini5.z.optional(import_mini5.z.string())
-});
-var ConfigOptionsSchema = import_mini5.z.object({
-  aiRulesDir: import_mini5.z.optional(import_mini5.z.string()),
-  outputPaths: import_mini5.z.optional(OutputPathsSchema),
-  watchEnabled: import_mini5.z.optional(import_mini5.z.boolean()),
-  defaultTargets: import_mini5.z.optional(ToolTargetsSchema),
-  targets: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
-  exclude: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
-  verbose: import_mini5.z.optional(import_mini5.z.boolean()),
-  delete: import_mini5.z.optional(import_mini5.z.boolean()),
-  baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
-  legacy: import_mini5.z.optional(import_mini5.z.boolean()),
-  watch: import_mini5.z.optional(
-    import_mini5.z.object({
-      enabled: import_mini5.z.optional(import_mini5.z.boolean()),
-      interval: import_mini5.z.optional(import_mini5.z.number()),
-      ignore: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
-    })
-  )
-});
-var MergedConfigSchema = import_mini5.z.object({
+var ConfigSchema = import_mini5.z.object({
   aiRulesDir: import_mini5.z.string(),
   outputPaths: import_mini5.z.record(ToolTargetSchema, import_mini5.z.string()),
   watchEnabled: import_mini5.z.boolean(),
   defaultTargets: ToolTargetsSchema,
-  targets: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
-  exclude: import_mini5.z.optional(import_mini5.z.array(ToolTargetSchema)),
-  verbose: import_mini5.z.optional(import_mini5.z.boolean()),
-  delete: import_mini5.z.optional(import_mini5.z.boolean()),
-  baseDir: import_mini5.z.optional(import_mini5.z.union([import_mini5.z.string(), import_mini5.z.array(import_mini5.z.string())])),
-  configPath: import_mini5.z.optional(import_mini5.z.string()),
-  legacy: import_mini5.z.optional(import_mini5.z.boolean()),
-  watch: import_mini5.z.optional(
-    import_mini5.z.object({
-      enabled: import_mini5.z.optional(import_mini5.z.boolean()),
-      interval: import_mini5.z.optional(import_mini5.z.number()),
-      ignore: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
-    })
-  )
+  claudecodeCommands: import_mini5.z.optional(import_mini5.z.string()),
+  geminicliCommands: import_mini5.z.optional(import_mini5.z.string()),
+  legacy: import_mini5.z.optional(import_mini5.z.boolean())
 });
 
 // src/types/mcp.ts
@@ -1439,6 +1483,7 @@ function getDefaultConfig() {
   return {
     aiRulesDir: ".rulesync",
     outputPaths: {
+      agentsmd: ".agents/memories",
       amazonqcli: ".amazonq/rules",
       augmentcode: ".",
       "augmentcode-legacy": ".",
@@ -1448,6 +1493,7 @@ function getDefaultConfig() {
       claudecode: ".",
       codexcli: ".",
       opencode: ".",
+      qwencode: ".qwen/memories",
       roo: ".roo/rules",
       geminicli: ".gemini/memories",
       kiro: ".kiro/steering",
@@ -1555,6 +1601,11 @@ function generateMinimalConfig(options) {
     if (comma) lines[lines.length - 1] += comma;
     lines.push(`  "exclude": ${JSON.stringify(options.exclude)}`);
   }
+  if (options.features) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "features": ${JSON.stringify(options.features)}`);
+  }
   if (options.aiRulesDir) {
     const comma = lines.length > 1 ? "," : "";
     if (comma) lines[lines.length - 1] += comma;
@@ -1595,6 +1646,7 @@ function generateMinimalConfig(options) {
 function generateSampleConfig(options) {
   const targets = options?.targets || ALL_TOOL_TARGETS;
   const excludeValue = options?.exclude ? JSON.stringify(options.exclude) : null;
+  const featuresValue = options?.features || ["rules", "commands", "mcp", "ignore", "subagents"];
   const aiRulesDir = options?.aiRulesDir || null;
   const baseDir = options?.baseDir || null;
   const deleteFlag = options?.delete || false;
@@ -1606,6 +1658,10 @@ function generateSampleConfig(options) {
   
   // Tools to exclude from generation (overrides targets)
   ${excludeValue ? `"exclude": ${excludeValue},` : '// "exclude": ["roo"],'}
+  
+  // Features to generate (rules, commands, mcp, ignore, subagents)
+  // Use "*" to generate all features, or specify an array of features
+  "features": ${JSON.stringify(featuresValue)},
   ${aiRulesDir ? `
   // Directory containing AI rule files
   "aiRulesDir": "${aiRulesDir}",` : ""}
@@ -1636,23 +1692,6 @@ function generateSampleConfig(options) {
 }
 `;
 }
-function mergeWithCliOptions(config, cliOptions) {
-  const merged = { ...config };
-  if (cliOptions.verbose !== void 0) {
-    merged.verbose = cliOptions.verbose;
-  }
-  if (cliOptions.delete !== void 0) {
-    merged.delete = cliOptions.delete;
-  }
-  if (cliOptions.baseDirs && cliOptions.baseDirs.length > 0) {
-    merged.baseDir = cliOptions.baseDirs;
-  }
-  if (cliOptions.tools && cliOptions.tools.length > 0) {
-    merged.defaultTargets = cliOptions.tools;
-    merged.exclude = void 0;
-  }
-  return merged;
-}
 
 // src/cli/commands/add.ts
 init_logger();
@@ -1761,6 +1800,11 @@ Default Targets: ${config.defaultTargets.join(", ")}`);
     if (config.exclude && config.exclude.length > 0) {
       logger.log(`Excluded Targets: ${config.exclude.join(", ")}`);
     }
+    if (config.features) {
+      const featuresDisplay = config.features === "*" ? "*" : Array.isArray(config.features) ? config.features.join(", ") : String(config.features);
+      logger.log(`
+Features: ${featuresDisplay}`);
+    }
     logger.log("\nOutput Paths:");
     for (const [tool, outputPath] of Object.entries(config.outputPaths)) {
       logger.log(`  ${tool}: ${outputPath}`);
@@ -1891,6 +1935,10 @@ const config: ConfigOptions = {
   // Available: ${ALL_TOOL_TARGETS.join(", ")}
   targets: ${JSON.stringify(ALL_TOOL_TARGETS)},
   
+  // Features to generate (rules, commands, mcp, ignore, subagents)
+  // Use "*" to generate all features, or specify an array of features
+  features: ["rules", "commands", "mcp", "ignore", "subagents"],
+  
   // Custom output paths for specific tools
   // outputPaths: {
   //   copilot: ".github/copilot-instructions.md",
@@ -1912,6 +1960,9 @@ export default config;`;
   if (options.exclude) {
     configLines.push(`  exclude: ${JSON.stringify(options.exclude)}`);
   }
+  if (options.features) {
+    configLines.push(`  features: ${JSON.stringify(options.features)}`);
+  }
   if (options.aiRulesDir) {
     configLines.push(`  aiRulesDir: "${options.aiRulesDir}"`);
   }
@@ -1944,7 +1995,7 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path13 = require("path");
+var import_node_path18 = require("path");
 
 // src/core/command-generator.ts
 var import_node_path5 = require("path");
@@ -2213,8 +2264,475 @@ async function generateCommands(projectRoot, baseDir, targets) {
   return outputs;
 }
 
-// src/generators/ignore/shared-factory.ts
+// src/utils/feature-validator.ts
+function isFeatureType(value) {
+  return FEATURE_TYPES.some((type) => type === value);
+}
+function validateFeatures(features) {
+  if (features === void 0) {
+    return "*";
+  }
+  if (features === "*") {
+    return "*";
+  }
+  if (!Array.isArray(features)) {
+    throw new Error('Features must be an array of feature names or "*"');
+  }
+  if (features.length === 0) {
+    throw new Error('Features array cannot be empty. Use "*" to include all features');
+  }
+  const validFeatures = [];
+  const invalidFeatures = [];
+  for (const feature of features) {
+    if (isFeatureType(feature)) {
+      validFeatures.push(feature);
+    } else {
+      invalidFeatures.push(feature);
+    }
+  }
+  if (invalidFeatures.length > 0) {
+    throw new Error(
+      `Invalid feature types: ${invalidFeatures.join(", ")}. Valid features are: ${FEATURE_TYPES.join(", ")}`
+    );
+  }
+  return [...new Set(validFeatures)];
+}
+function expandWildcard() {
+  return [...FEATURE_TYPES];
+}
+function normalizeFeatures(features) {
+  if (features === "*" || features === void 0) {
+    return expandWildcard();
+  }
+  return features;
+}
+
+// src/core/config/cli-parser.ts
+var CliParser = class {
+  /**
+   * CLI引数を解析する
+   * @param cliOptions - 生のCLIオプション
+   * @returns 解析されたCliOptions
+   */
+  parse(cliOptions) {
+    const parsed = {};
+    if (cliOptions.tools && Array.isArray(cliOptions.tools) && cliOptions.tools.length > 0) {
+      parsed.tools = cliOptions.tools;
+    }
+    if (cliOptions.features !== void 0) {
+      try {
+        parsed.features = validateFeatures(cliOptions.features);
+      } catch (error) {
+        throw new Error(
+          `Invalid features: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (typeof cliOptions.verbose === "boolean") {
+      parsed.verbose = cliOptions.verbose;
+    }
+    if (typeof cliOptions.delete === "boolean") {
+      parsed.delete = cliOptions.delete;
+    }
+    if (cliOptions.baseDirs && Array.isArray(cliOptions.baseDirs) && cliOptions.baseDirs.length > 0) {
+      parsed.baseDirs = cliOptions.baseDirs;
+    }
+    if (typeof cliOptions.config === "string") {
+      parsed.config = cliOptions.config;
+    }
+    if (typeof cliOptions.noConfig === "boolean") {
+      parsed.noConfig = cliOptions.noConfig;
+    }
+    return parsed;
+  }
+  /**
+   * CLI引数が有効かどうかを検証する
+   * @param cliOptions - 検証するCLIオプション
+   * @returns 検証結果
+   */
+  validate(cliOptions) {
+    const errors = [];
+    if (cliOptions.config && cliOptions.noConfig) {
+      errors.push("--config and --no-config cannot be used together");
+    }
+    if (cliOptions.baseDirs && cliOptions.baseDirs.length === 0) {
+      errors.push("--base-dirs cannot be empty");
+    }
+    if (cliOptions.tools && cliOptions.tools.length === 0) {
+      errors.push("--tools cannot be empty");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/core/config/config-file-loader.ts
 var import_node_path6 = require("path");
+var ConfigFileLoader = class {
+  /**
+   * 設定ファイルを読み込む
+   * @param options - 設定ファイルの読み込みオプション
+   * @returns 設定ファイルの読み込み結果
+   */
+  async load(options = {}) {
+    try {
+      return await loadConfig(options);
+    } catch (error) {
+      throw new Error(
+        `Failed to load configuration file: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * 設定ファイルが存在するかどうかを確認する
+   * @param configPath - 設定ファイルのパス
+   * @returns ファイルが存在するかどうか
+   */
+  async exists(configPath) {
+    try {
+      const { access } = await import("fs/promises");
+      await access(configPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 設定ファイルのパスを解決する
+   * @param configPath - 指定された設定ファイルのパス
+   * @param workingDirectory - 作業ディレクトリ
+   * @returns 解決された設定ファイルのパス
+   */
+  resolvePath(configPath, workingDirectory) {
+    if (!configPath) {
+      return void 0;
+    }
+    if ((0, import_node_path6.isAbsolute)(configPath)) {
+      return configPath;
+    }
+    const baseDir = workingDirectory || process.cwd();
+    return (0, import_node_path6.resolve)(baseDir, configPath);
+  }
+};
+
+// src/core/config/config-merger.ts
+var ConfigMerger = class {
+  /**
+   * 設定ファイルとCLI引数をマージする
+   * @param fileConfig - 設定ファイルから読み込まれた設定
+   * @param cliOptions - CLI引数から解析された設定
+   * @returns マージされた設定
+   */
+  merge(fileConfig, cliOptions) {
+    const merged = { ...fileConfig };
+    if (cliOptions.verbose !== void 0) {
+      merged.verbose = cliOptions.verbose;
+    }
+    if (cliOptions.delete !== void 0) {
+      merged.delete = cliOptions.delete;
+    }
+    if (cliOptions.baseDirs && cliOptions.baseDirs.length > 0) {
+      merged.baseDir = cliOptions.baseDirs;
+    }
+    if (cliOptions.tools && cliOptions.tools.length > 0) {
+      merged.defaultTargets = cliOptions.tools;
+      merged.exclude = void 0;
+    }
+    if (cliOptions.features !== void 0) {
+      merged.features = cliOptions.features;
+    }
+    return merged;
+  }
+  /**
+   * 設定値のマージメタデータを生成する
+   * @param fileConfig - 設定ファイルの設定
+   * @param cliOptions - CLI引数の設定
+   * @param merged - マージされた設定
+   * @returns マージメタデータ
+   */
+  generateMetadata(fileConfig, cliOptions, merged) {
+    const metadata = {};
+    if (merged.verbose !== void 0) {
+      metadata.verbose = {
+        source: cliOptions.verbose !== void 0 ? "cli_args" /* CLI_ARGS */ : "config_file" /* CONFIG_FILE */,
+        value: merged.verbose
+      };
+    }
+    if (merged.delete !== void 0) {
+      metadata.delete = {
+        source: cliOptions.delete !== void 0 ? "cli_args" /* CLI_ARGS */ : "config_file" /* CONFIG_FILE */,
+        value: merged.delete
+      };
+    }
+    if (merged.baseDir !== void 0) {
+      metadata.baseDir = {
+        source: cliOptions.baseDirs ? "cli_args" /* CLI_ARGS */ : "config_file" /* CONFIG_FILE */,
+        value: merged.baseDir
+      };
+    }
+    metadata.defaultTargets = {
+      source: cliOptions.tools ? "cli_args" /* CLI_ARGS */ : "config_file" /* CONFIG_FILE */,
+      value: merged.defaultTargets
+    };
+    if (merged.exclude !== void 0) {
+      metadata.exclude = {
+        source: "config_file" /* CONFIG_FILE */,
+        // excludeはCLIから直接指定されない
+        value: merged.exclude
+      };
+    }
+    if (merged.features !== void 0) {
+      metadata.features = {
+        source: cliOptions.features !== void 0 ? "cli_args" /* CLI_ARGS */ : "config_file" /* CONFIG_FILE */,
+        value: merged.features
+      };
+    }
+    return metadata;
+  }
+  /**
+   * マージされた設定を検証する
+   * @param config - マージされた設定
+   * @returns 検証結果
+   */
+  validate(config) {
+    const errors = [];
+    if (!config.defaultTargets || config.defaultTargets.length === 0) {
+      errors.push("At least one tool must be specified in targets or CLI arguments");
+    }
+    if (!config.aiRulesDir) {
+      errors.push("aiRulesDir must be specified");
+    }
+    if (!config.outputPaths) {
+      errors.push("outputPaths must be specified");
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+
+// src/core/config/validators.ts
+var ConfigValidationError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.errors = errors;
+    this.name = "ConfigValidationError";
+  }
+};
+var ConfigValidator = class {
+  /**
+   * CLI引数を検証する
+   * @param cliOptions - 検証するCLI引数
+   * @throws {ConfigValidationError} バリデーションエラーが発生した場合
+   */
+  validateCliOptions(cliOptions) {
+    const errors = [];
+    if (cliOptions.config && cliOptions.noConfig) {
+      errors.push("--config and --no-config cannot be used together");
+    }
+    if (cliOptions.baseDirs && cliOptions.baseDirs.length === 0) {
+      errors.push("--base-dirs cannot be empty");
+    }
+    if (cliOptions.tools && cliOptions.tools.length === 0) {
+      errors.push("--tools cannot be empty");
+    }
+    if (cliOptions.baseDirs) {
+      for (const [index, dir] of cliOptions.baseDirs.entries()) {
+        if (typeof dir !== "string" || dir.trim() === "") {
+          errors.push(`Base directory at index ${index} must be a non-empty string`);
+        }
+      }
+    }
+    if (errors.length > 0) {
+      throw new ConfigValidationError("CLI options validation failed", errors);
+    }
+  }
+  /**
+   * マージされた設定を検証する
+   * @param config - 検証する設定
+   * @throws {ConfigValidationError} バリデーションエラーが発生した場合
+   */
+  validateMergedConfig(config) {
+    const errors = [];
+    if (!config.aiRulesDir || config.aiRulesDir.trim() === "") {
+      errors.push("aiRulesDir must be specified and non-empty");
+    }
+    if (!config.outputPaths) {
+      errors.push("outputPaths must be specified");
+    }
+    if (!config.defaultTargets || config.defaultTargets.length === 0) {
+      errors.push("At least one tool must be specified in defaultTargets");
+    }
+    if (config.watchEnabled === void 0) {
+      errors.push("watchEnabled must be specified");
+    }
+    if (config.baseDir !== void 0) {
+      const dirs = Array.isArray(config.baseDir) ? config.baseDir : [config.baseDir];
+      for (const [index, dir] of dirs.entries()) {
+        if (typeof dir !== "string" || dir.trim() === "") {
+          errors.push(`Base directory at index ${index} must be a non-empty string`);
+        }
+      }
+    }
+    if (config.exclude && config.defaultTargets) {
+      const invalidExcludes = config.exclude.filter(
+        (excludeTool) => !config.defaultTargets.includes(excludeTool)
+      );
+      if (invalidExcludes.length > 0) {
+        errors.push(`Exclude contains tools not in defaultTargets: ${invalidExcludes.join(", ")}`);
+      }
+    }
+    if (errors.length > 0) {
+      throw new ConfigValidationError("Merged configuration validation failed", errors);
+    }
+  }
+  /**
+   * 設定ファイルのパスが有効かどうかを検証する
+   * @param configPath - 設定ファイルのパス
+   * @throws {ConfigValidationError} パスが無効な場合
+   */
+  validateConfigPath(configPath) {
+    if (configPath !== void 0 && typeof configPath !== "string") {
+      throw new ConfigValidationError("Configuration validation failed", [
+        "Config path must be a string"
+      ]);
+    }
+    if (typeof configPath === "string" && configPath.trim() === "") {
+      throw new ConfigValidationError("Configuration validation failed", [
+        "Config path cannot be empty"
+      ]);
+    }
+  }
+  /**
+   * 作業ディレクトリが有効かどうかを検証する
+   * @param workingDirectory - 作業ディレクトリのパス
+   * @throws {ConfigValidationError} パスが無効な場合
+   */
+  validateWorkingDirectory(workingDirectory) {
+    if (workingDirectory !== void 0 && typeof workingDirectory !== "string") {
+      throw new ConfigValidationError("Configuration validation failed", [
+        "Working directory must be a string"
+      ]);
+    }
+    if (typeof workingDirectory === "string" && workingDirectory.trim() === "") {
+      throw new ConfigValidationError("Configuration validation failed", [
+        "Working directory cannot be empty"
+      ]);
+    }
+  }
+};
+
+// src/core/config/config-resolver.ts
+var ConfigResolver = class {
+  cliParser;
+  configLoader;
+  merger;
+  validator;
+  constructor(cliParser, configLoader, merger, validator) {
+    this.cliParser = cliParser || new CliParser();
+    this.configLoader = configLoader || new ConfigFileLoader();
+    this.merger = merger || new ConfigMerger();
+    this.validator = validator || new ConfigValidator();
+  }
+  /**
+   * 設定を解決してマージされた設定を返す
+   * @param options - 設定解決のオプション
+   * @returns 解決された設定と詳細情報
+   */
+  async resolve(options) {
+    try {
+      this.validator.validateWorkingDirectory(options.workingDirectory);
+      const parsedCliOptions = this.cliParser.parse(options.cliOptions);
+      this.validator.validateCliOptions(parsedCliOptions);
+      const configLoaderOptions = {
+        cwd: options.workingDirectory || process.cwd(),
+        ...parsedCliOptions.config && { configPath: parsedCliOptions.config },
+        ...parsedCliOptions.noConfig && { noConfig: parsedCliOptions.noConfig }
+      };
+      this.validator.validateConfigPath(configLoaderOptions.configPath);
+      const configResult = await this.configLoader.load(configLoaderOptions);
+      const mergedConfig = this.merger.merge(configResult.config, parsedCliOptions);
+      this.validator.validateMergedConfig(mergedConfig);
+      const metadata = this.merger.generateMetadata(
+        configResult.config,
+        parsedCliOptions,
+        mergedConfig
+      );
+      const configSource = this.determineConfigSource(configResult.isEmpty, parsedCliOptions);
+      return {
+        value: mergedConfig,
+        source: configSource,
+        metadata
+      };
+    } catch (error) {
+      if (error instanceof ConfigValidationError) {
+        throw error;
+      }
+      throw new Error(
+        `Failed to resolve configuration: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * 設定の主要なソースを判定する
+   * @param configFileEmpty - 設定ファイルが空かどうか
+   * @param cliOptions - CLI引数
+   * @returns 主要な設定ソース
+   */
+  determineConfigSource(configFileEmpty, cliOptions) {
+    if (cliOptions.tools || cliOptions.verbose !== void 0 || cliOptions.delete !== void 0) {
+      return "cli_args" /* CLI_ARGS */;
+    }
+    if (!configFileEmpty) {
+      return "config_file" /* CONFIG_FILE */;
+    }
+    return "default" /* DEFAULT */;
+  }
+  /**
+   * 設定解決の詳細情報を取得する（デバッグ用）
+   * @param options - 設定解決のオプション
+   * @returns 詳細な解決情報
+   */
+  async resolveWithDetails(options) {
+    const parsedCliOptions = this.cliParser.parse(options.cliOptions);
+    const configLoaderOptions = {
+      cwd: options.workingDirectory || process.cwd(),
+      ...parsedCliOptions.config && { configPath: parsedCliOptions.config },
+      ...parsedCliOptions.noConfig && { noConfig: parsedCliOptions.noConfig }
+    };
+    const configFileResult = await this.configLoader.load(configLoaderOptions);
+    try {
+      const result = await this.resolve(options);
+      return {
+        result,
+        details: {
+          parsedCliOptions,
+          configFileResult
+        }
+      };
+    } catch (error) {
+      const validationErrors = error instanceof ConfigValidationError ? error.errors : [error instanceof Error ? error.message : String(error)];
+      const partialConfig = this.merger.merge(configFileResult.config, parsedCliOptions);
+      return {
+        result: {
+          value: partialConfig,
+          source: this.determineConfigSource(configFileResult.isEmpty, parsedCliOptions)
+        },
+        details: {
+          parsedCliOptions,
+          configFileResult,
+          validationErrors
+        }
+      };
+    }
+  }
+};
+
+// src/generators/ignore/shared-factory.ts
+var import_node_path7 = require("path");
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
@@ -2337,7 +2855,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path6.join)(outputPath, ignoreConfig.filename);
+  const filepath = (0, import_node_path7.join)(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -2919,17 +3437,114 @@ async function generateKiroIgnoreFiles(rules, config, baseDir) {
   return generateIgnoreFile(rules, config, ignoreConfigs.kiro, baseDir);
 }
 
+// src/generators/ignore/qwencode.ts
+var import_node_path8 = 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_path8.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/agentsmd.ts
+init_file();
+async function generateAgentsMdConfig(rules, config, baseDir) {
+  const outputs = [];
+  const nonEmptyRules = rules.filter((rule) => rule.content.trim().length > 0);
+  if (nonEmptyRules.length > 0) {
+    const rootRule = nonEmptyRules.find((rule) => rule.frontmatter.root);
+    const detailRules = nonEmptyRules.filter((rule) => !rule.frontmatter.root);
+    if (rootRule) {
+      const agentsPath = resolvePath("AGENTS.md", baseDir);
+      const agentsContent = generateAgentsMarkdown(rootRule);
+      outputs.push({
+        tool: "agentsmd",
+        filepath: agentsPath,
+        content: agentsContent
+      });
+    }
+    for (const rule of detailRules) {
+      const memoryPath = resolvePath(`.agents/memories/${rule.filename}.md`, baseDir);
+      const memoryContent = generateMemoryMarkdown(rule);
+      outputs.push({
+        tool: "agentsmd",
+        filepath: memoryPath,
+        content: memoryContent
+      });
+    }
+  }
+  return outputs;
+}
+function generateAgentsMarkdown(rootRule) {
+  return rootRule.content.trim();
+}
+function generateMemoryMarkdown(rule) {
+  return rule.content.trim();
+}
+
 // src/generators/rules/shared-helpers.ts
-var import_node_path8 = require("path");
+var import_node_path10 = require("path");
 init_file();
 
 // src/utils/ignore.ts
-var import_node_path7 = require("path");
+var import_node_path9 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
 init_file();
 init_logger();
@@ -2938,7 +3553,7 @@ async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path7.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path9.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -2992,21 +3607,35 @@ 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_path10.join)(outputDir, relativePath),
     content
   });
 }
 async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   const outputs = [];
-  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 nonEmptyRules = rules.filter((rule) => rule.content.trim().length > 0);
+  if (nonEmptyRules.length === 0) {
+    return outputs;
+  }
+  if (generatorConfig.singleFileMode && generatorConfig.fileName && generatorConfig.generateCombinedContent) {
+    const filepath = resolvePath(generatorConfig.fileName, baseDir);
+    const content = generatorConfig.generateCombinedContent(nonEmptyRules);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
       content
     });
+  } else if (generatorConfig.fileExtension) {
+    for (const rule of nonEmptyRules) {
+      const content = generatorConfig.generateContent(rule);
+      const outputDir = resolveOutputDir(config, generatorConfig.tool, baseDir);
+      const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path10.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+      outputs.push({
+        tool: generatorConfig.tool,
+        filepath,
+        content
+      });
+    }
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0 && generatorConfig.ignoreFileName) {
@@ -3029,7 +3658,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_path10.join)(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -3137,7 +3766,7 @@ function generateRuleFile(rule) {
 }
 
 // src/generators/rules/augmentcode.ts
-var import_node_path9 = require("path");
+var import_node_path11 = require("path");
 async function generateAugmentcodeConfig(rules, config, baseDir) {
   const outputs = createOutputsArray();
   rules.forEach((rule) => {
@@ -3146,7 +3775,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      (0, import_node_path9.join)(".augment", "rules", `${rule.filename}.md`),
+      (0, import_node_path11.join)(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile2(rule)
     );
   });
@@ -3199,7 +3828,7 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path10 = require("path");
+var import_node_path12 = require("path");
 init_file();
 init_logger();
 async function generateClaudecodeConfig(rules, config, baseDir) {
@@ -3213,7 +3842,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_path12.join)(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -3277,7 +3906,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/generator-registry.ts
-var import_node_path11 = require("path");
+var import_node_path13 = require("path");
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -3301,6 +3930,15 @@ function determineCursorRuleType(frontmatter) {
 }
 var GENERATOR_REGISTRY = {
   // Simple generators - generate one file per rule
+  agentsmd: {
+    type: "complex",
+    tool: "agentsmd",
+    fileExtension: ".md",
+    ignoreFileName: ".agentsignore",
+    generateContent: (rule) => rule.content.trim()
+    // NOTE: AGENTS.md specific logic is handled in the actual generator file
+    // Root rule goes to AGENTS.md, detail rules go to .agents/memories/
+  },
   amazonqcli: {
     type: "complex",
     tool: "amazonqcli",
@@ -3373,7 +4011,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_path13.join)(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -3413,7 +4051,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_path13.join)(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -3449,10 +4087,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_path13.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_path13.join)(outputDir, ".windsurf", "rules");
+        return (0, import_node_path13.join)(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -3515,6 +4153,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
+  },
+  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());
@@ -3571,9 +4225,60 @@ var generateCopilotConfig = createSimpleGenerator("copilot");
 var generateWindsurfConfig = createSimpleGenerator("windsurf");
 var generateKiroConfig = createSimpleGenerator("kiro");
 var generateRooConfig = createSimpleGenerator("roo");
+var generateQwencodeConfig = createSimpleGenerator("qwencode");
+
+// src/generators/rules/base-generator.ts
+async function generateBaseRulesConfig(rules, config, generatorConfig, baseDir) {
+  const unifiedConfig = {
+    tool: generatorConfig.tool,
+    fileName: generatorConfig.fileName,
+    ...generatorConfig.ignoreFileName ? { ignoreFileName: generatorConfig.ignoreFileName } : {},
+    singleFileMode: true,
+    generateCombinedContent: generatorConfig.generateContent,
+    generateContent: () => ""
+    // Not used in single file mode
+  };
+  return generateRulesConfig(rules, config, unifiedConfig, baseDir);
+}
+function categorizeRules(rules) {
+  return rules.reduce(
+    (acc, rule) => {
+      if (rule.frontmatter.root) {
+        acc.root.push(rule);
+      } else {
+        acc.detail.push(rule);
+      }
+      return acc;
+    },
+    { root: [], detail: [] }
+  );
+}
+function generateMarkdownContent(rules) {
+  const sections = [];
+  const categorized = categorizeRules(rules);
+  if (categorized.root.length > 0) {
+    sections.push(...categorized.root.map((rule) => rule.content.trim()));
+  }
+  if (categorized.detail.length > 0) {
+    sections.push(...categorized.detail.map((rule) => rule.content.trim()));
+  }
+  return sections.join("\n\n").trim();
+}
 
 // src/generators/rules/codexcli.ts
-init_file();
+async function generateCodexConfig(rules, config, baseDir) {
+  return generateBaseRulesConfig(
+    rules,
+    config,
+    {
+      fileName: "AGENTS.md",
+      ignoreFileName: ".codexignore",
+      generateContent: generateMarkdownContent,
+      tool: "codexcli"
+    },
+    baseDir
+  );
+}
 
 // src/utils/xml-document-generator.ts
 var import_fast_xml_parser = require("fast-xml-parser");
@@ -3619,47 +4324,6 @@ function generateRootMarkdownWithXmlDocs(rootRule, memoryRules, config) {
   return lines.join("\n");
 }
 
-// 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
-      });
-    }
-  }
-  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
 async function generateGeminiConfig(rules, config, baseDir) {
   const generatorConfig = {
@@ -3717,21 +4381,39 @@ async function generateOpenCodeConfig(rules, config, baseDir) {
     tool: "opencode",
     fileExtension: ".md",
     // ignoreFileName omitted - OpenCode doesn't use dedicated ignore files
-    generateContent: generateOpenCodeMarkdown,
-    generateDetailContent: generateOpenCodeMarkdown,
-    generateRootContent: generateOpenCodeRootMarkdown,
+    generateContent: (rule) => rule.content.trim(),
+    generateDetailContent: (rule) => rule.content.trim(),
+    generateRootContent: (rootRule, memoryRules) => generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
+      memorySubDir: ".opencode/memories",
+      fallbackTitle: "OpenCode Configuration"
+    }),
     rootFilePath: "AGENTS.md",
     detailSubDir: ".opencode/memories"
   };
   return generateComplexRules(rules, config, generatorConfig, baseDir);
 }
-function generateOpenCodeMarkdown(rule) {
+
+// 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 generateOpenCodeRootMarkdown(rootRule, memoryRules, _baseDir) {
+function generateQwenRootMarkdown(rootRule, memoryRules, _baseDir) {
   return generateRootMarkdownWithXmlDocs(rootRule, memoryRules, {
-    memorySubDir: ".opencode/memories",
-    fallbackTitle: "OpenCode Configuration"
+    memorySubDir: ".qwen/memories",
+    fallbackTitle: "Qwen Code Configuration"
   });
 }
 
@@ -3768,6 +4450,8 @@ function filterRulesForTool(rules, tool, config) {
 }
 async function generateForTool(tool, rules, config, baseDir) {
   switch (tool) {
+    case "agentsmd":
+      return await generateAgentsMdConfig(rules, config, baseDir);
     case "amazonqcli":
       return await generateAmazonqcliConfig(rules, config, baseDir);
     case "augmentcode": {
@@ -3810,6 +4494,11 @@ async function generateForTool(tool, rules, config, baseDir) {
     }
     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);
@@ -3822,7 +4511,7 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path12 = require("path");
+var import_node_path14 = require("path");
 init_logger();
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
@@ -3876,7 +4565,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_path14.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -3954,6 +4643,7 @@ init_cursor();
 init_geminicli();
 init_junie();
 init_kiro();
+init_qwencode();
 init_roo();
 init_windsurf();
 
@@ -3991,10 +4681,12 @@ function parseMcpConfig(projectRoot) {
 async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
   const outputs = [];
   const toolMap = {
+    agentsmd: async () => [],
     amazonqcli: async (servers, dir) => {
       const config = {
         aiRulesDir: ".rulesync",
         outputPaths: {
+          agentsmd: ".agents/memories",
           amazonqcli: ".amazonq/rules",
           augmentcode: ".",
           "augmentcode-legacy": ".",
@@ -4004,6 +4696,7 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
           claudecode: ".",
           codexcli: ".",
           opencode: ".",
+          qwencode: ".qwen/memories",
           roo: ".roo/rules",
           geminicli: ".gemini/memories",
           kiro: ".kiro/steering",
@@ -4047,6 +4740,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
@@ -4068,223 +4765,594 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
   return outputs;
 }
 
-// src/cli/commands/generate.ts
+// src/core/subagent-generator.ts
+var import_node_path17 = __toESM(require("path"), 1);
+
+// src/generators/subagents/claudecode.ts
 init_logger();
-async function generateCommand(options = {}) {
-  const configLoaderOptions = {
-    ...options.config !== void 0 && { configPath: options.config },
-    ...options.noConfig !== void 0 && { noConfig: options.noConfig }
-  };
-  const configResult = await loadConfig(configLoaderOptions);
-  const cliOptions = {
-    ...options.tools !== void 0 && { 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("");
-    }
-  }
-  let baseDirs;
-  if (config.baseDir) {
-    baseDirs = Array.isArray(config.baseDir) ? config.baseDir : [config.baseDir];
-  } else if (options.baseDirs) {
-    baseDirs = options.baseDirs;
-  } else {
-    baseDirs = [process.cwd()];
+
+// src/generators/subagents/base.ts
+var import_node_path15 = __toESM(require("path"), 1);
+init_file();
+init_logger();
+var BaseSubagentGenerator = class {
+  /**
+   * Generate subagent files for the tool
+   */
+  async generate(rules, config, baseDir, parsedSubagents) {
+    const toolName = this.getToolName();
+    const agentsDir = this.getAgentsDirectory();
+    const outputs = [];
+    try {
+      const outputDir = resolvePath(
+        import_node_path15.default.join(config.outputPaths[toolName] ?? "", agentsDir),
+        baseDir
+      );
+      await ensureDir(outputDir);
+      let subagentOutputs;
+      if (parsedSubagents && parsedSubagents.length > 0) {
+        logger.debug(
+          `Generating ${parsedSubagents.length} subagents from parsed data for ${toolName}`
+        );
+        subagentOutputs = this.generateFromParsedSubagents(parsedSubagents);
+      } else {
+        logger.debug(`Generating subagents from rules for ${toolName}`);
+        subagentOutputs = this.generateFromRules(rules);
+      }
+      for (const subagent of subagentOutputs) {
+        const filePath = import_node_path15.default.join(outputDir, subagent.filename);
+        outputs.push({
+          tool: toolName,
+          filepath: filePath,
+          content: subagent.content
+        });
+      }
+      if (outputs.length > 0) {
+        logger.info(`Generated ${outputs.length} subagent files for ${toolName}`);
+      } else {
+        logger.debug(`No subagents generated for ${toolName}`);
+      }
+      return outputs;
+    } catch (error) {
+      logger.error(`Error generating subagents for ${toolName}:`, error);
+      return [];
+    }
   }
-  logger.info(`Loaded configuration from: ${configResult.filepath}`);
-  logger.log("Generating configuration files...");
-  if (!await fileExists(config.aiRulesDir)) {
-    logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
-    process.exit(1);
+};
+
+// src/generators/subagents/claudecode.ts
+var ClaudeCodeSubagentGenerator = class extends BaseSubagentGenerator {
+  getToolName() {
+    return "claudecode";
+  }
+  getAgentsDirectory() {
+    return ".claude/agents";
+  }
+  generateFromRules(_rules) {
+    logger.debug("Skipping rule-to-subagent conversion (deprecated behavior)");
+    return [];
+  }
+  generateFromParsedSubagents(subagents) {
+    return subagents.map((subagent) => {
+      const frontmatterLines = ["---"];
+      frontmatterLines.push(`name: ${subagent.frontmatter.name}`);
+      frontmatterLines.push(`description: ${subagent.frontmatter.description}`);
+      if (subagent.frontmatter.claudecode?.model) {
+        frontmatterLines.push(`model: ${subagent.frontmatter.claudecode.model}`);
+      }
+      frontmatterLines.push("---");
+      const content = `${frontmatterLines.join("\n")}
+
+${subagent.content}`;
+      return {
+        filename: `${subagent.filename}.md`,
+        content
+      };
+    });
+  }
+  processContent(subagent) {
+    const frontmatterLines = ["---"];
+    frontmatterLines.push(`name: ${subagent.frontmatter.name}`);
+    frontmatterLines.push(`description: ${subagent.frontmatter.description}`);
+    if (subagent.frontmatter.claudecode?.model) {
+      frontmatterLines.push(`model: ${subagent.frontmatter.claudecode.model}`);
+    }
+    frontmatterLines.push("---");
+    return `${frontmatterLines.join("\n")}
+
+${subagent.content}`;
+  }
+};
+
+// src/parsers/subagent-parser.ts
+var import_promises3 = require("fs/promises");
+var import_node_path16 = __toESM(require("path"), 1);
+var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+
+// src/types/subagent.ts
+var import_mini8 = require("zod/mini");
+var ClaudeCodeConfigSchema = import_mini8.z.object({
+  model: import_mini8.z.optional(import_mini8.z.string())
+});
+var SubagentFrontmatterSchema = import_mini8.z.object({
+  name: import_mini8.z.string(),
+  description: import_mini8.z.string(),
+  targets: import_mini8.z.optional(import_mini8.z.array(import_mini8.z.string())),
+  // Tool-specific configurations
+  claudecode: import_mini8.z.optional(ClaudeCodeConfigSchema)
+});
+
+// src/parsers/subagent-parser.ts
+init_file();
+init_logger();
+async function parseSubagentFile(filepath) {
+  try {
+    const fileContent = await (0, import_promises3.readFile)(filepath, "utf-8");
+    const { data: frontmatter, content } = (0, import_gray_matter2.default)(fileContent);
+    const result = SubagentFrontmatterSchema.safeParse(frontmatter);
+    if (!result.success) {
+      logger.warn(`Invalid frontmatter in ${filepath}: ${result.error.message}`);
+      return null;
+    }
+    const parsedFrontmatter = result.data;
+    if (!parsedFrontmatter.targets) {
+      parsedFrontmatter.targets = ["*"];
+    }
+    const filename = import_node_path16.default.basename(filepath, import_node_path16.default.extname(filepath));
+    return {
+      frontmatter: parsedFrontmatter,
+      content: content.trim(),
+      filename,
+      filepath
+    };
+  } catch (error) {
+    logger.error(`Error parsing subagent file ${filepath}:`, error);
+    return null;
+  }
+}
+async function parseSubagentsFromDirectory(agentsDir) {
+  try {
+    if (!await fileExists(agentsDir)) {
+      logger.debug(`Agents directory does not exist: ${agentsDir}`);
+      return [];
+    }
+    const entries = await (0, import_promises3.readdir)(agentsDir);
+    const mdFiles = entries.filter((file) => file.endsWith(".md"));
+    const files = mdFiles.map((file) => import_node_path16.default.join(agentsDir, file));
+    if (files.length === 0) {
+      logger.debug(`No subagent files found in ${agentsDir}`);
+      return [];
+    }
+    logger.debug(`Found ${files.length} subagent files in ${agentsDir}`);
+    const parsePromises = files.map((file) => parseSubagentFile(file));
+    const results = await Promise.all(parsePromises);
+    const subagents = results.filter((result) => result !== null);
+    logger.info(`Successfully parsed ${subagents.length} subagents`);
+    return subagents;
+  } catch (error) {
+    logger.error(`Error parsing subagents from directory ${agentsDir}:`, error);
+    return [];
   }
+}
+
+// src/core/subagent-generator.ts
+init_logger();
+async function generateSubagents(rulesyncDir, outputDir, tools, rules) {
+  const outputs = [];
+  const subagentsDir = import_node_path17.default.join(rulesyncDir, "subagents");
+  let parsedSubagents = [];
   try {
-    logger.info(`Parsing rules from ${config.aiRulesDir}...`);
-    const rules = await parseRulesFromDirectory(config.aiRulesDir);
-    if (rules.length === 0) {
-      logger.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
-      return;
+    parsedSubagents = await parseSubagentsFromDirectory(subagentsDir);
+    if (parsedSubagents.length > 0) {
+      logger.debug(`Found ${parsedSubagents.length} subagent files in ${subagentsDir}`);
     }
-    logger.info(`Found ${rules.length} rule(s)`);
-    logger.info(`Base directories: ${baseDirs.join(", ")}`);
-    if (config.delete) {
-      logger.info("Deleting existing output directories...");
-      const targetTools = config.defaultTargets;
-      const deleteTasks = [];
-      const commandsDir = (0, import_node_path13.join)(config.aiRulesDir, "commands");
-      const hasCommands = await fileExists(commandsDir);
-      let hasCommandFiles = false;
-      if (hasCommands) {
-        const { readdir: readdir2 } = await import("fs/promises");
-        try {
-          const files = await readdir2(commandsDir);
-          hasCommandFiles = files.some((file) => file.endsWith(".md"));
-        } catch {
-          hasCommandFiles = false;
+  } catch (error) {
+    logger.debug(`No subagents directory found or error reading: ${error}`);
+  }
+  if (!tools || tools.length === 0) {
+    return outputs;
+  }
+  const config = {
+    aiRulesDir: rulesyncDir,
+    outputPaths: {
+      agentsmd: ".",
+      amazonqcli: ".",
+      augmentcode: ".augment",
+      "augmentcode-legacy": ".",
+      copilot: ".github",
+      cursor: ".cursor",
+      cline: ".",
+      claudecode: ".",
+      codexcli: ".",
+      opencode: ".",
+      qwencode: ".",
+      roo: ".roo",
+      geminicli: ".gemini",
+      kiro: ".kiro",
+      junie: ".junie",
+      windsurf: ".windsurf"
+    },
+    watchEnabled: false,
+    defaultTargets: tools
+  };
+  for (const tool of tools) {
+    try {
+      let generator;
+      switch (tool) {
+        case "claudecode":
+          generator = new ClaudeCodeSubagentGenerator();
+          break;
+        // Add other tool generators here as they are implemented
+        default:
+          logger.debug(`Subagent generation not yet implemented for ${tool}`);
+          continue;
+      }
+      const generatedOutputs = await generator.generate(
+        parsedSubagents.length > 0 ? [] : rules || [],
+        config,
+        outputDir,
+        parsedSubagents
+      );
+      for (const output of generatedOutputs) {
+        outputs.push({
+          tool,
+          filepath: output.filepath,
+          content: output.content
+        });
+      }
+    } catch (error) {
+      logger.error(`Failed to generate subagents for ${tool}:`, error);
+    }
+  }
+  return outputs;
+}
+
+// src/cli/commands/generate.ts
+init_logger();
+
+// src/cli/commands/shared-utils.ts
+init_logger();
+function showBackwardCompatibilityWarning(commandName, exampleCommand) {
+  const yellow = "\x1B[33m";
+  const gray = "\x1B[90m";
+  const cyan = "\x1B[36m";
+  const reset = "\x1B[0m";
+  logger.warn(
+    `
+${yellow}\u26A0\uFE0F  Warning: No --features option specified.${reset}
+${gray}Currently ${commandName} all features for backward compatibility.${reset}
+${gray}In future versions, this behavior may change.${reset}
+${gray}Please specify --features explicitly:${reset}
+${cyan}  ${exampleCommand}${reset}
+${gray}Or use --features * to ${commandName.replace("ing", "")} all features.${reset}
+`
+  );
+}
+
+// src/cli/commands/generate.ts
+async function generateCommand(options = {}) {
+  try {
+    const cliParser = new CliParser();
+    const cliInputs = {};
+    if (options.tools !== void 0) cliInputs.tools = options.tools;
+    if (options.features !== void 0) cliInputs.features = options.features;
+    if (options.verbose !== void 0) cliInputs.verbose = options.verbose;
+    if (options.delete !== void 0) cliInputs.delete = options.delete;
+    if (options.baseDirs !== void 0) cliInputs.baseDirs = options.baseDirs;
+    if (options.config !== void 0) cliInputs.config = options.config;
+    if (options.noConfig !== void 0) cliInputs.noConfig = options.noConfig;
+    const cliOptions = cliParser.parse(cliInputs);
+    const configResolver = new ConfigResolver();
+    const resolutionResult = await configResolver.resolve({
+      cliOptions
+    });
+    const config = resolutionResult.value;
+    let resolvedFeatures;
+    let showWarning = false;
+    if (cliOptions.features !== void 0) {
+      resolvedFeatures = cliOptions.features;
+    } else if (config.features !== void 0) {
+      resolvedFeatures = config.features;
+    } else {
+      resolvedFeatures = "*";
+      showWarning = true;
+    }
+    if (showWarning) {
+      showBackwardCompatibilityWarning(
+        "generating",
+        "rulesync generate --features rules,commands,mcp,ignore"
+      );
+    }
+    const normalizedFeatures = normalizeFeatures(resolvedFeatures);
+    if (!config.defaultTargets || config.defaultTargets.length === 0) {
+      const errorMessage = `\u274C Error: At least one tool must be specified.
+
+You can specify tools in three ways:
+
+1. Use the --targets flag:
+   rulesync generate --targets copilot,cursor
+
+2. Use the --all flag to generate for all tools:
+   rulesync generate --all
+
+3. Set targets in rulesync.jsonc:
+   {
+     "targets": ["copilot", "cursor"]
+   }
+
+Available tools:
+  agentsmd, amazonqcli, augmentcode, augmentcode-legacy, copilot, cursor, cline,
+  claudecode, codexcli, opencode, qwencode, roo, geminicli, kiro, junie, windsurf`;
+      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];
+    } else if (options.baseDirs) {
+      baseDirs = options.baseDirs;
+    } else {
+      baseDirs = [process.cwd()];
+    }
+    logger.info(`Configuration resolved from: ${resolutionResult.source}`);
+    logger.log("Generating configuration files...");
+    if (!await fileExists(config.aiRulesDir)) {
+      logger.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
+      process.exit(1);
+    }
+    try {
+      logger.info(`Parsing rules from ${config.aiRulesDir}...`);
+      const rules = await parseRulesFromDirectory(config.aiRulesDir);
+      if (rules.length === 0) {
+        logger.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
+        return;
+      }
+      logger.info(`Found ${rules.length} rule(s)`);
+      logger.info(`Base directories: ${baseDirs.join(", ")}`);
+      if (config.delete) {
+        logger.info("Deleting existing output directories...");
+        const targetTools = config.defaultTargets;
+        const deleteTasks = [];
+        const commandsDir = (0, import_node_path18.join)(config.aiRulesDir, "commands");
+        const hasCommands = await fileExists(commandsDir);
+        let hasCommandFiles = false;
+        if (hasCommands) {
+          const { readdir: readdir3 } = await import("fs/promises");
+          try {
+            const files = await readdir3(commandsDir);
+            hasCommandFiles = files.some((file) => file.endsWith(".md"));
+          } catch {
+            hasCommandFiles = false;
+          }
+        }
+        for (const tool of targetTools) {
+          switch (tool) {
+            case "augmentcode":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".augment", "rules")));
+              }
+              if (normalizedFeatures.includes("ignore")) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".augment", "ignore")));
+              }
+              break;
+            case "augmentcode-legacy":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeClaudeGeneratedFiles());
+              }
+              if (normalizedFeatures.includes("ignore")) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".augment", "ignore")));
+              }
+              break;
+            case "copilot":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.copilot));
+              }
+              break;
+            case "cursor":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.cursor));
+              }
+              break;
+            case "cline":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.cline));
+              }
+              break;
+            case "claudecode":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeClaudeGeneratedFiles());
+              }
+              if (normalizedFeatures.includes("commands") && hasCommandFiles) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".claude", "commands")));
+              }
+              if (normalizedFeatures.includes("subagents")) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".claude", "agents")));
+              }
+              break;
+            case "roo":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.roo));
+              }
+              if (normalizedFeatures.includes("commands") && hasCommandFiles) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".roo", "commands")));
+              }
+              break;
+            case "geminicli":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
+              }
+              if (normalizedFeatures.includes("commands") && hasCommandFiles) {
+                deleteTasks.push(removeDirectory((0, import_node_path18.join)(".gemini", "commands")));
+              }
+              break;
+            case "kiro":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.kiro));
+              }
+              break;
+            case "opencode":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.opencode));
+              }
+              break;
+            case "qwencode":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.qwencode));
+              }
+              break;
+            case "windsurf":
+              if (normalizedFeatures.includes("rules")) {
+                deleteTasks.push(removeDirectory(config.outputPaths.windsurf));
+              }
+              break;
+          }
+        }
+        await Promise.all(deleteTasks);
+        logger.info("Deleted existing output directories");
+      }
+      let totalOutputs = 0;
+      if (normalizedFeatures.includes("rules")) {
+        for (const baseDir of baseDirs) {
+          logger.info(`
+Generating rule configurations for base directory: ${baseDir}`);
+          const outputs = await generateConfigurations(
+            rules,
+            config,
+            config.defaultTargets,
+            baseDir
+          );
+          if (outputs.length === 0) {
+            logger.warn(`\u26A0\uFE0F  No rule configurations generated for ${baseDir}`);
+            continue;
+          }
+          for (const output of outputs) {
+            await writeFileContent(output.filepath, output.content);
+            logger.success(`Generated ${output.tool} rule configuration: ${output.filepath}`);
+          }
+          totalOutputs += outputs.length;
         }
+      } else {
+        logger.info("\nSkipping rule generation (not in --features)");
       }
-      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")));
-            break;
-          case "augmentcode-legacy":
-            deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path13.join)(".augment", "ignore")));
-            break;
-          case "copilot":
-            deleteTasks.push(removeDirectory(config.outputPaths.copilot));
-            break;
-          case "cursor":
-            deleteTasks.push(removeDirectory(config.outputPaths.cursor));
-            break;
-          case "cline":
-            deleteTasks.push(removeDirectory(config.outputPaths.cline));
-            break;
-          case "claudecode":
-            deleteTasks.push(removeClaudeGeneratedFiles());
-            if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".claude", "commands")));
+      let totalMcpOutputs = 0;
+      if (normalizedFeatures.includes("mcp")) {
+        logger.info("\nGenerating MCP configurations...");
+        for (const baseDir of baseDirs) {
+          try {
+            const mcpConfig = parseMcpConfig(process.cwd());
+            if (!mcpConfig || !mcpConfig.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
+              logger.info(`No MCP configuration found for ${baseDir}`);
+              continue;
             }
-            break;
-          case "roo":
-            deleteTasks.push(removeDirectory(config.outputPaths.roo));
-            if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".roo", "commands")));
+            const mcpResults = await generateMcpConfigurations(
+              mcpConfig,
+              baseDir === process.cwd() ? "." : baseDir,
+              config.defaultTargets
+            );
+            if (mcpResults.length === 0) {
+              logger.info(`No MCP configurations generated for ${baseDir}`);
+              continue;
             }
-            break;
-          case "geminicli":
-            deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
-            if (hasCommandFiles) {
-              deleteTasks.push(removeDirectory((0, import_node_path13.join)(".gemini", "commands")));
+            for (const result of mcpResults) {
+              await writeFileContent(result.filepath, result.content);
+              logger.success(`Generated ${result.tool} MCP configuration: ${result.filepath}`);
+              totalMcpOutputs++;
             }
-            break;
-          case "kiro":
-            deleteTasks.push(removeDirectory(config.outputPaths.kiro));
-            break;
-          case "opencode":
-            deleteTasks.push(removeDirectory(config.outputPaths.opencode));
-            break;
-          case "windsurf":
-            deleteTasks.push(removeDirectory(config.outputPaths.windsurf));
-            break;
+          } catch (error) {
+            logger.error(
+              `\u274C Failed to generate MCP configurations: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
         }
+      } else {
+        logger.info("\nSkipping MCP configuration generation (not in --features)");
       }
-      await Promise.all(deleteTasks);
-      logger.info("Deleted existing output directories");
-    }
-    let totalOutputs = 0;
-    for (const baseDir of baseDirs) {
-      logger.info(`
-Generating configurations for base directory: ${baseDir}`);
-      const outputs = await generateConfigurations(rules, config, config.defaultTargets, baseDir);
-      if (outputs.length === 0) {
-        logger.warn(`\u26A0\uFE0F  No configurations generated for ${baseDir}`);
-        continue;
+      let totalCommandOutputs = 0;
+      if (normalizedFeatures.includes("commands")) {
+        logger.info("\nGenerating command files...");
+        for (const baseDir of baseDirs) {
+          const commandResults = await generateCommands(
+            process.cwd(),
+            baseDir === process.cwd() ? void 0 : baseDir,
+            config.defaultTargets
+          );
+          if (commandResults.length === 0) {
+            logger.info(`No commands found for ${baseDir}`);
+            continue;
+          }
+          for (const result of commandResults) {
+            await writeFileContent(result.filepath, result.content);
+            logger.success(`Generated ${result.tool} command: ${result.filepath}`);
+            totalCommandOutputs++;
+          }
+        }
+      } else {
+        logger.info("\nSkipping command file generation (not in --features)");
       }
-      for (const output of outputs) {
-        await writeFileContent(output.filepath, output.content);
-        logger.success(`Generated ${output.tool} configuration: ${output.filepath}`);
+      const totalIgnoreOutputs = 0;
+      if (normalizedFeatures.includes("ignore")) {
+        logger.info("\nGenerating ignore files...");
+        logger.info("Ignore file generation is not yet implemented");
+      } else {
+        logger.info("\nSkipping ignore file generation (not in --features)");
       }
-      totalOutputs += outputs.length;
-    }
-    if (totalOutputs === 0) {
-      logger.warn("\u26A0\uFE0F  No configurations generated");
-      return;
-    }
-    logger.info("\nGenerating MCP configurations...");
-    let totalMcpOutputs = 0;
-    for (const baseDir of baseDirs) {
-      try {
-        const mcpConfig = parseMcpConfig(process.cwd());
-        if (!mcpConfig || !mcpConfig.mcpServers || Object.keys(mcpConfig.mcpServers).length === 0) {
-          logger.info(`No MCP configuration found for ${baseDir}`);
-          continue;
-        }
-        const mcpResults = await generateMcpConfigurations(
-          mcpConfig,
-          baseDir === process.cwd() ? "." : baseDir,
-          config.defaultTargets
-        );
-        if (mcpResults.length === 0) {
-          logger.info(`No MCP configurations generated for ${baseDir}`);
-          continue;
-        }
-        for (const result of mcpResults) {
-          await writeFileContent(result.filepath, result.content);
-          logger.success(`Generated ${result.tool} MCP configuration: ${result.filepath}`);
-          totalMcpOutputs++;
+      let totalSubagentOutputs = 0;
+      if (normalizedFeatures.includes("subagents")) {
+        logger.info("\nGenerating subagent files...");
+        for (const baseDir of baseDirs) {
+          const subagentResults = await generateSubagents(
+            config.aiRulesDir,
+            baseDir === process.cwd() ? void 0 : baseDir,
+            config.defaultTargets,
+            rules
+          );
+          if (subagentResults.length === 0) {
+            logger.info(`No subagents generated for ${baseDir}`);
+            continue;
+          }
+          for (const result of subagentResults) {
+            await writeFileContent(result.filepath, result.content);
+            logger.success(`Generated ${result.tool} subagent: ${result.filepath}`);
+            totalSubagentOutputs++;
+          }
         }
-      } catch (error) {
-        logger.error(
-          `\u274C Failed to generate MCP configurations: ${error instanceof Error ? error.message : String(error)}`
-        );
+      } else {
+        logger.info("\nSkipping subagent file generation (not in --features)");
       }
-    }
-    logger.info("\nGenerating command files...");
-    let totalCommandOutputs = 0;
-    for (const baseDir of baseDirs) {
-      const commandResults = await generateCommands(
-        process.cwd(),
-        baseDir === process.cwd() ? void 0 : baseDir,
-        config.defaultTargets
-      );
-      if (commandResults.length === 0) {
-        logger.info(`No commands found for ${baseDir}`);
-        continue;
-      }
-      for (const result of commandResults) {
-        await writeFileContent(result.filepath, result.content);
-        logger.success(`Generated ${result.tool} command: ${result.filepath}`);
-        totalCommandOutputs++;
-      }
-    }
-    const totalGenerated = totalOutputs + totalMcpOutputs + totalCommandOutputs;
-    if (totalGenerated > 0) {
-      const parts = [];
-      if (totalOutputs > 0) parts.push(`${totalOutputs} configurations`);
-      if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP configurations`);
-      if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
-      logger.success(
-        `
+      const totalGenerated = totalOutputs + totalMcpOutputs + totalCommandOutputs + totalIgnoreOutputs + totalSubagentOutputs;
+      if (totalGenerated === 0) {
+        const enabledFeatures = normalizedFeatures.join(", ");
+        logger.warn(`\u26A0\uFE0F  No files generated for enabled features: ${enabledFeatures}`);
+        return;
+      }
+      if (totalGenerated > 0) {
+        const parts = [];
+        if (totalOutputs > 0) parts.push(`${totalOutputs} configurations`);
+        if (totalMcpOutputs > 0) parts.push(`${totalMcpOutputs} MCP configurations`);
+        if (totalCommandOutputs > 0) parts.push(`${totalCommandOutputs} commands`);
+        if (totalSubagentOutputs > 0) parts.push(`${totalSubagentOutputs} subagents`);
+        logger.success(
+          `
 \u{1F389} All done! Generated ${totalGenerated} file(s) total (${parts.join(" + ")})`
-      );
+        );
+      }
+    } catch (error) {
+      logger.error("\u274C Failed to generate configurations:", error);
+      process.exit(1);
     }
   } catch (error) {
-    logger.error("\u274C Failed to generate configurations:", error);
+    logger.error("\u274C Failed to resolve configuration:", error);
     process.exit(1);
   }
 }
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path14 = require("path");
+var import_node_path19 = require("path");
 init_logger();
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path14.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path19.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.amazonq/rules/",
@@ -4298,7 +5366,9 @@ var gitignoreCommand = async () => {
     "**/CLAUDE.md",
     "**/.claude/memories/",
     "**/.claude/commands/",
+    "**/.claude/agents/",
     "**/AGENTS.md",
+    "**/.agents/",
     "**/.codexignore",
     "**/.roo/rules/",
     "**/.rooignore",
@@ -4306,6 +5376,8 @@ var gitignoreCommand = async () => {
     "**/GEMINI.md",
     "**/.gemini/memories/",
     "**/.gemini/commands/",
+    "**/QWEN.md",
+    "**/.qwen/memories/",
     "**/.aiexclude",
     "**/.aiignore",
     "**/.augmentignore",
@@ -4324,6 +5396,7 @@ var gitignoreCommand = async () => {
     "**/.vscode/mcp.json",
     "**/.codex/mcp-config.json",
     "**/.gemini/settings.json",
+    "**/.qwen/settings.json",
     "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
@@ -4355,11 +5428,155 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path21 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"), 1);
+var import_node_path28 = require("path");
+var import_gray_matter3 = __toESM(require("gray-matter"), 1);
+
+// src/parsers/agentsmd.ts
+var import_node_path20 = require("path");
+async function parseAgentsMdConfiguration(baseDir = process.cwd()) {
+  const errors = [];
+  const rules = [];
+  const projectAgentsPath = (0, import_node_path20.join)(baseDir, "AGENTS.md");
+  if (await fileExists(projectAgentsPath)) {
+    try {
+      const content = await readFileContent(projectAgentsPath);
+      if (content.trim()) {
+        const frontmatter = {
+          root: true,
+          targets: ["agentsmd"],
+          description: "Project-level AGENTS.md instructions",
+          globs: ["**/*"]
+        };
+        rules.push({
+          frontmatter,
+          content: content.trim(),
+          filename: "project-instructions",
+          filepath: projectAgentsPath
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse AGENTS.md: ${errorMessage}`);
+    }
+  }
+  const memoriesDir = (0, import_node_path20.join)(baseDir, ".agents", "memories");
+  if (await fileExists(memoriesDir)) {
+    try {
+      const { readdir: readdir3, stat: stat2 } = await import("fs/promises");
+      const memoriesPath = memoriesDir;
+      const memoriesStat = await stat2(memoriesPath);
+      if (memoriesStat.isDirectory()) {
+        const files = await readdir3(memoriesPath);
+        for (const file of files) {
+          if (file.endsWith(".md")) {
+            const filePath = (0, import_node_path20.join)(memoriesPath, file);
+            try {
+              const content = await readFileContent(filePath);
+              if (content.trim()) {
+                const filename = file.replace(/\.md$/, "");
+                const frontmatter = {
+                  root: false,
+                  targets: ["agentsmd"],
+                  description: `AGENTS.md memory: ${filename}`,
+                  globs: ["**/*"]
+                };
+                rules.push({
+                  frontmatter,
+                  content: content.trim(),
+                  filename,
+                  filepath: filePath
+                });
+              }
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              errors.push(`Failed to parse memory file ${file}: ${errorMessage}`);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const { readdir: readdir3 } = await import("fs/promises");
+    const files = await readdir3(baseDir);
+    for (const file of files) {
+      if (file === "AGENTS.md") continue;
+      if (file.endsWith(".md") && (file.includes("agents") || file.includes("instructions") || file.includes("guidelines") || file.includes("rules"))) {
+        const filePath = (0, import_node_path20.join)(baseDir, file);
+        try {
+          const content = await readFileContent(filePath);
+          if (content.trim()) {
+            const filename = file.replace(/\.md$/, "");
+            const frontmatter = {
+              root: false,
+              targets: ["agentsmd"],
+              description: `AGENTS.md instructions: ${filename}`,
+              globs: ["**/*"]
+            };
+            rules.push({
+              frontmatter,
+              content: content.trim(),
+              filename,
+              filepath: filePath
+            });
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          errors.push(`Failed to parse ${file}: ${errorMessage}`);
+        }
+      }
+    }
+    for (const file of files) {
+      const filePath = (0, import_node_path20.join)(baseDir, file);
+      try {
+        const { stat: stat2 } = await import("fs/promises");
+        const stats = await stat2(filePath);
+        if (stats.isDirectory() && !file.startsWith(".") && file !== "node_modules") {
+          const subAgentsPath = (0, import_node_path20.join)(filePath, "AGENTS.md");
+          if (await fileExists(subAgentsPath)) {
+            try {
+              const content = await readFileContent(subAgentsPath);
+              if (content.trim()) {
+                const frontmatter = {
+                  root: false,
+                  targets: ["agentsmd"],
+                  description: `Directory-specific AGENTS.md instructions: ${file}`,
+                  globs: [`${file}/**/*`]
+                };
+                rules.push({
+                  frontmatter,
+                  content: content.trim(),
+                  filename: `${file}-agents`,
+                  filepath: subAgentsPath
+                });
+              }
+            } catch (error) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              errors.push(`Failed to parse ${subAgentsPath}: ${errorMessage}`);
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to scan directory for AGENTS.md files: ${errorMessage}`);
+  }
+  if (rules.length === 0) {
+    errors.push(
+      "No AGENTS.md configuration files found. Expected to find AGENTS.md in the project root or memory files in .agents/memories/."
+    );
+  }
+  return {
+    rules,
+    errors
+  };
+}
 
 // src/parsers/shared-helpers.ts
-var import_node_path15 = require("path");
+var import_node_path21 = require("path");
 init_file();
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
@@ -4413,11 +5630,11 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
       const dirPath = resolvePath(dirConfig.directory, baseDir);
       if (await fileExists(dirPath)) {
         const result = await safeAsyncOperation(async () => {
-          const { readdir: readdir2 } = await import("fs/promises");
-          const files = await readdir2(dirPath);
+          const { readdir: readdir3 } = await import("fs/promises");
+          const files = await readdir3(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = (0, import_node_path15.join)(dirPath, file);
+              const filePath = (0, import_node_path21.join)(dirPath, file);
               const fileResult = await safeAsyncOperation(async () => {
                 const rawContent = await readFileContent(filePath);
                 let content;
@@ -4564,14 +5781,14 @@ function parseMainFile(content, filepath, config) {
 async function parseMemoryFiles(memoryDir, config) {
   const rules = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(memoryDir);
+    const { readdir: readdir3 } = await import("fs/promises");
+    const files = await readdir3(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path15.join)(memoryDir, file);
+        const filePath = (0, import_node_path21.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path15.basename)(file, ".md");
+          const filename = (0, import_node_path21.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -4594,14 +5811,14 @@ async function parseMemoryFiles(memoryDir, config) {
 async function parseCommandsFiles(commandsDir, config) {
   const rules = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(commandsDir);
+    const { readdir: readdir3 } = await import("fs/promises");
+    const files = await readdir3(commandsDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path15.join)(commandsDir, file);
+        const filePath = (0, import_node_path21.join)(commandsDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path15.basename)(file, ".md");
+          const filename = (0, import_node_path21.basename)(file, ".md");
           let frontmatter;
           let ruleContent;
           try {
@@ -4690,7 +5907,7 @@ async function parseAmazonqcliConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/augmentcode.ts
-var import_node_path16 = require("path");
+var import_node_path22 = require("path");
 
 // src/utils/parser-helpers.ts
 function createParseResult() {
@@ -4738,7 +5955,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = (0, import_node_path16.join)(baseDir, config.rulesDir);
+    const rulesDir = (0, import_node_path22.join)(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -4751,7 +5968,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = (0, import_node_path16.join)(baseDir, config.legacyFilePath);
+    const legacyPath = (0, import_node_path22.join)(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -4771,11 +5988,11 @@ async function parseAugmentRules(rulesDir, config) {
   const rules = [];
   const errors = [];
   try {
-    const { readdir: readdir2 } = await import("fs/promises");
-    const files = await readdir2(rulesDir);
+    const { readdir: readdir3 } = await import("fs/promises");
+    const files = await readdir3(rulesDir);
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = (0, import_node_path16.join)(rulesDir, file);
+        const filePath = (0, import_node_path22.join)(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
           const parsed = parseFrontmatter(rawContent);
@@ -4783,7 +6000,7 @@ async function parseAugmentRules(rulesDir, config) {
           const description = extractStringField(parsed.data, "description", "");
           const tags = extractArrayField(parsed.data, "tags");
           const isRoot = ruleType === "always";
-          const filename = (0, import_node_path16.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = (0, import_node_path22.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: [config.targetName],
@@ -4841,8 +6058,9 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/claudecode.ts
+init_file();
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
-  return parseMemoryBasedConfiguration(baseDir, {
+  const memoryResult = await parseMemoryBasedConfiguration(baseDir, {
     tool: "claudecode",
     mainFileName: "CLAUDE.md",
     memoryDirPath: ".claude/memories",
@@ -4852,6 +6070,24 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     filenamePrefix: "claude",
     commandsDirPath: ".claude/commands"
   });
+  const result = {
+    rules: memoryResult.rules,
+    errors: memoryResult.errors
+  };
+  if (memoryResult.ignorePatterns) {
+    result.ignorePatterns = memoryResult.ignorePatterns;
+  }
+  if (memoryResult.mcpServers) {
+    result.mcpServers = memoryResult.mcpServers;
+  }
+  const agentsDir = resolvePath(".claude/agents", baseDir);
+  if (await fileExists(agentsDir)) {
+    const subagents = await parseSubagentsFromDirectory(agentsDir);
+    if (subagents.length > 0) {
+      result.subagents = subagents;
+    }
+  }
+  return result;
 }
 
 // src/parsers/cline.ts
@@ -4875,7 +6111,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-var import_node_path17 = require("path");
+var import_node_path23 = require("path");
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -4898,9 +6134,9 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path18 = require("path");
+var import_node_path24 = require("path");
 var import_js_yaml = require("js-yaml");
-var import_mini8 = require("zod/mini");
+var import_mini9 = require("zod/mini");
 var customMatterOptions = {
   engines: {
     yaml: {
@@ -4928,7 +6164,7 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const FrontmatterSchema = import_mini8.z.record(import_mini8.z.string(), import_mini8.z.unknown());
+  const FrontmatterSchema = import_mini9.z.record(import_mini9.z.string(), import_mini9.z.unknown());
   const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
   if (!parseResult.success) {
     return {
@@ -5022,7 +6258,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_path24.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -5043,20 +6279,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_path24.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
-      const { readdir: readdir2 } = await import("fs/promises");
-      const files = await readdir2(cursorRulesDir);
+      const { readdir: readdir3 } = await import("fs/promises");
+      const files = await readdir3(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path18.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path24.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_path24.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -5079,7 +6315,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_path24.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -5092,7 +6328,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_path24.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -5115,6 +6351,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
+var import_node_path25 = require("path");
 async function parseAiexclude(aiexcludePath) {
   try {
     const content = await readFileContent(aiexcludePath);
@@ -5124,8 +6361,51 @@ async function parseAiexclude(aiexcludePath) {
     return [];
   }
 }
+async function parseGeminiCommands(commandsDir) {
+  const rules = [];
+  try {
+    const { readdir: readdir3 } = await import("fs/promises");
+    const { parse } = await import("smol-toml");
+    const files = await readdir3(commandsDir);
+    for (const file of files) {
+      if (file.endsWith(".toml")) {
+        const filePath = (0, import_node_path25.join)(commandsDir, file);
+        const content = await readFileContent(filePath);
+        if (content.trim()) {
+          const filename = (0, import_node_path25.basename)(file, ".toml");
+          try {
+            const parsed = parse(content);
+            if (typeof parsed !== "object" || parsed === null) {
+              continue;
+            }
+            const commandConfig = parsed;
+            if (typeof commandConfig.prompt === "string") {
+              const description = typeof commandConfig.description === "string" ? commandConfig.description : `Command: ${filename}`;
+              const frontmatter = {
+                root: false,
+                targets: ["geminicli"],
+                description,
+                globs: ["**/*"]
+              };
+              rules.push({
+                frontmatter,
+                content: commandConfig.prompt,
+                filename,
+                filepath: filePath,
+                type: "command"
+              });
+            }
+          } catch {
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return rules;
+}
 async function parseGeminiConfiguration(baseDir = process.cwd()) {
-  return parseMemoryBasedConfiguration(baseDir, {
+  const result = await parseMemoryBasedConfiguration(baseDir, {
     tool: "geminicli",
     mainFileName: "GEMINI.md",
     memoryDirPath: ".gemini/memories",
@@ -5136,17 +6416,23 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     additionalIgnoreFile: {
       path: ".aiexclude",
       parser: parseAiexclude
-    },
-    commandsDirPath: ".gemini/commands"
+    }
+    // commandsDirPath is removed - Gemini uses .toml files which need special handling
   });
+  const commandsDir = resolvePath(".gemini/commands", baseDir);
+  if (await fileExists(commandsDir)) {
+    const commandsRules = await parseGeminiCommands(commandsDir);
+    result.rules.push(...commandsRules);
+  }
+  return result;
 }
 
 // src/parsers/junie.ts
-var import_node_path19 = require("path");
+var import_node_path26 = 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_path26.join)(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -5203,6 +6489,22 @@ async function parseOpenCodeConfiguration(baseDir = process.cwd()) {
   });
 }
 
+// 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, {
@@ -5224,8 +6526,8 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/windsurf.ts
-var import_promises3 = require("fs/promises");
-var import_node_path20 = require("path");
+var import_promises4 = require("fs/promises");
+var import_node_path27 = require("path");
 init_logger();
 
 // src/core/importer.ts
@@ -5233,6 +6535,8 @@ init_logger();
 async function importConfiguration(options) {
   const {
     tool,
+    features = ["rules", "commands", "mcp", "ignore", "subagents"],
+    // Default to all features for backward compatibility
     baseDir = process.cwd(),
     rulesDir = ".rulesync",
     verbose = false,
@@ -5242,11 +6546,18 @@ async function importConfiguration(options) {
   let rules = [];
   let ignorePatterns;
   let mcpServers;
+  let subagents;
   if (verbose) {
     logger.log(`Importing ${tool} configuration from ${baseDir}...`);
   }
   try {
     switch (tool) {
+      case "agentsmd": {
+        const agentsmdResult = await parseAgentsMdConfiguration(baseDir);
+        rules = agentsmdResult.rules;
+        errors.push(...agentsmdResult.errors);
+        break;
+      }
       case "amazonqcli": {
         const amazonqResult = await parseAmazonqcliConfiguration(baseDir);
         rules = amazonqResult.rules;
@@ -5272,6 +6583,7 @@ async function importConfiguration(options) {
         errors.push(...claudeResult.errors);
         ignorePatterns = claudeResult.ignorePatterns;
         mcpServers = claudeResult.mcpServers;
+        subagents = claudeResult.subagents;
         break;
       }
       case "cursor": {
@@ -5322,6 +6634,13 @@ async function importConfiguration(options) {
         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 };
@@ -5331,10 +6650,20 @@ async function importConfiguration(options) {
     errors.push(`Failed to parse ${tool} configuration: ${errorMessage}`);
     return { success: false, rulesCreated: 0, errors };
   }
-  if (rules.length === 0 && !ignorePatterns && !mcpServers) {
+  if (rules.length === 0 && !ignorePatterns && !mcpServers && !subagents) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path21.join)(baseDir, rulesDir);
+  const rulesEnabled = features.includes("rules") || features.includes("commands");
+  const ignoreEnabled = features.includes("ignore");
+  const mcpEnabled = features.includes("mcp");
+  const subagentsEnabled = features.includes("subagents");
+  if (!rulesEnabled && !ignoreEnabled && !mcpEnabled && !subagentsEnabled) {
+    if (verbose) {
+      logger.log("No relevant features enabled for import");
+    }
+    return { success: false, rulesCreated: 0, errors: ["No features enabled for import"] };
+  }
+  const rulesDirPath = (0, import_node_path28.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -5344,37 +6673,49 @@ async function importConfiguration(options) {
     return { success: false, rulesCreated: 0, errors };
   }
   let rulesCreated = 0;
-  for (const rule of rules) {
-    try {
-      const baseFilename = rule.filename;
-      let targetDir = rulesDirPath;
-      if (rule.type === "command") {
-        targetDir = (0, import_node_path21.join)(rulesDirPath, "commands");
-        const { mkdir: mkdir3 } = await import("fs/promises");
-        await mkdir3(targetDir, { recursive: true });
-      } else {
-        if (!useLegacyLocation) {
-          targetDir = (0, import_node_path21.join)(rulesDirPath, "rules");
+  if (rulesEnabled) {
+    for (const rule of rules) {
+      try {
+        const baseFilename = rule.filename;
+        let targetDir = rulesDirPath;
+        if (rule.type === "command") {
+          if (!features.includes("commands")) {
+            continue;
+          }
+          targetDir = (0, import_node_path28.join)(rulesDirPath, "commands");
           const { mkdir: mkdir3 } = await import("fs/promises");
           await mkdir3(targetDir, { recursive: true });
+        } else {
+          if (!features.includes("rules")) {
+            continue;
+          }
+          if (!useLegacyLocation) {
+            targetDir = (0, import_node_path28.join)(rulesDirPath, "rules");
+            const { mkdir: mkdir3 } = await import("fs/promises");
+            await mkdir3(targetDir, { recursive: true });
+          }
         }
+        const filePath = (0, import_node_path28.join)(targetDir, `${baseFilename}.md`);
+        const content = generateRuleFileContent(rule);
+        await writeFileContent(filePath, content);
+        rulesCreated++;
+        if (verbose) {
+          logger.success(`Created rule file: ${filePath}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        errors.push(`Failed to create rule file for ${rule.filename}: ${errorMessage}`);
       }
-      const filePath = (0, import_node_path21.join)(targetDir, `${baseFilename}.md`);
-      const content = generateRuleFileContent(rule);
-      await writeFileContent(filePath, content);
-      rulesCreated++;
-      if (verbose) {
-        logger.success(`Created rule file: ${filePath}`);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      errors.push(`Failed to create rule file for ${rule.filename}: ${errorMessage}`);
+    }
+  } else {
+    if (verbose && rules.length > 0) {
+      logger.log(`Skipping ${rules.length} rule(s) (rules/commands features not enabled)`);
     }
   }
   let ignoreFileCreated = false;
-  if (ignorePatterns && ignorePatterns.length > 0) {
+  if (ignoreEnabled && ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path21.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path28.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -5386,11 +6727,13 @@ async function importConfiguration(options) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       errors.push(`Failed to create .rulesyncignore: ${errorMessage}`);
     }
+  } else if (verbose && ignorePatterns && ignorePatterns.length > 0 && !ignoreEnabled) {
+    logger.log(`Skipping ignore patterns (ignore feature not enabled)`);
   }
   let mcpFileCreated = false;
-  if (mcpServers && Object.keys(mcpServers).length > 0) {
+  if (mcpEnabled && mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path21.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path28.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -5402,14 +6745,51 @@ async function importConfiguration(options) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       errors.push(`Failed to create .mcp.json: ${errorMessage}`);
     }
+  } else if (verbose && mcpServers && Object.keys(mcpServers).length > 0 && !mcpEnabled) {
+    logger.log(`Skipping MCP configuration (mcp feature not enabled)`);
   }
-  return {
-    success: errors.length === 0 && (rulesCreated > 0 || ignoreFileCreated || mcpFileCreated),
+  let subagentsCreated = 0;
+  if (subagentsEnabled && subagents && subagents.length > 0) {
+    try {
+      const { mkdir: mkdir3 } = await import("fs/promises");
+      const subagentsDir = (0, import_node_path28.join)(baseDir, rulesDir, "subagents");
+      await mkdir3(subagentsDir, { recursive: true });
+      for (const subagent of subagents) {
+        try {
+          const filename = `${subagent.filename}.md`;
+          const filepath = (0, import_node_path28.join)(subagentsDir, filename);
+          const content = generateSubagentFileContent(subagent);
+          await writeFileContent(filepath, content);
+          subagentsCreated++;
+          if (verbose) {
+            logger.success(`Created subagent: ${filename}`);
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          errors.push(`Failed to create subagent ${subagent.filename}: ${errorMessage}`);
+        }
+      }
+      if (verbose && subagentsCreated > 0) {
+        logger.success(`Created ${subagentsCreated} subagent files`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to create subagents directory: ${errorMessage}`);
+    }
+  } else if (verbose && subagents && subagents.length > 0 && !subagentsEnabled) {
+    logger.log(`Skipping subagents (subagents feature not enabled)`);
+  }
+  const result = {
+    success: errors.length === 0 && (rulesCreated > 0 || ignoreFileCreated || mcpFileCreated || subagentsCreated > 0),
     rulesCreated,
     errors,
     ignoreFileCreated,
     mcpFileCreated
   };
+  if (subagentsCreated > 0) {
+    result.subagentsCreated = subagentsCreated;
+  }
+  return result;
 }
 function generateRuleFileContent(rule) {
   if (rule.type === "command") {
@@ -5417,69 +6797,109 @@ function generateRuleFileContent(rule) {
       description: rule.frontmatter.description,
       targets: rule.frontmatter.targets
     };
-    const frontmatter2 = import_gray_matter2.default.stringify("", simplifiedFrontmatter);
+    const frontmatter2 = import_gray_matter3.default.stringify("", simplifiedFrontmatter);
     return frontmatter2 + rule.content;
   }
-  const frontmatter = import_gray_matter2.default.stringify("", rule.frontmatter);
+  const frontmatter = import_gray_matter3.default.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
+function generateSubagentFileContent(subagent) {
+  const frontmatter = import_gray_matter3.default.stringify("", subagent.frontmatter);
+  return frontmatter + subagent.content;
+}
 
 // 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");
-  if (options.cursor) tools.push("cursor");
-  if (options.copilot) tools.push("copilot");
-  if (options.cline) tools.push("cline");
-  if (options.roo) tools.push("roo");
-  if (options.geminicli) tools.push("geminicli");
-  if (options.opencode) tools.push("opencode");
-  if (tools.length === 0) {
-    logger.error(
-      "\u274C Please specify one tool to import from (--amazonqcli, --augmentcode, --augmentcode-legacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli, --opencode)"
+  let resolvedFeatures;
+  let showWarning = false;
+  if (options.features !== void 0) {
+    resolvedFeatures = options.features;
+  } else {
+    resolvedFeatures = "*";
+    showWarning = true;
+  }
+  if (showWarning) {
+    showBackwardCompatibilityWarning(
+      "importing",
+      "rulesync import --targets cursor,copilot --features rules,mcp,ignore"
     );
+  }
+  const normalizedFeatures = normalizeFeatures(resolvedFeatures);
+  let tools = [];
+  if (options.targets && options.targets.length > 0) {
+    tools = options.targets;
+  } else {
+    if (options.agentsmd) tools.push("agentsmd");
+    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");
+    if (options.cursor) tools.push("cursor");
+    if (options.copilot) tools.push("copilot");
+    if (options.cline) tools.push("cline");
+    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.opencode) tools.push("opencode");
+  }
+  if (tools.length === 0) {
+    logger.error("\u274C Please specify a tool to import from using --targets <tool>.");
+    logger.info("Example: rulesync import --targets cursor");
     process.exit(1);
   }
   if (tools.length > 1) {
     logger.error(
-      "\u274C Only one tool can be specified at a time. Please run the import command separately for each tool."
+      `\u274C Import command only supports a single target.
+You specified: ${tools.join(", ")}
+
+Please run the command separately for each tool:`
     );
+    for (const tool2 of tools) {
+      logger.info(`  rulesync import --targets ${tool2}`);
+    }
     process.exit(1);
   }
   const tool = tools[0];
   if (!tool) {
-    logger.error("Error: No tool specified");
+    logger.error("\u274C Unexpected error: No tool selected");
     process.exit(1);
   }
   logger.log(`Importing configuration files from ${tool}...`);
   try {
     const result = await importConfiguration({
       tool,
+      features: normalizedFeatures,
       verbose: options.verbose ?? false,
       useLegacyLocation: options.legacy ?? false
     });
     if (result.success) {
-      logger.success(`Imported ${result.rulesCreated} rule(s) from ${tool}`);
+      logger.success(`\u2705 Imported ${result.rulesCreated} rule(s) from ${tool}`);
       if (result.ignoreFileCreated) {
-        logger.success("Created .rulesyncignore file from ignore patterns");
+        logger.success("  Created .rulesyncignore file from ignore patterns");
       }
       if (result.mcpFileCreated) {
-        logger.success("Created .rulesync/.mcp.json file from MCP configuration");
+        logger.success("  Created .rulesync/.mcp.json file from MCP configuration");
+      }
+      if (result.subagentsCreated) {
+        logger.success(`  Created ${result.subagentsCreated} subagent files`);
       }
+      logger.success(`
+\u{1F389} Successfully imported from ${tool}`);
       logger.log("You can now run 'rulesync generate' to create tool-specific configurations.");
     } else if (result.errors.length > 0) {
       logger.warn(`\u26A0\uFE0F  Failed to import from ${tool}: ${result.errors[0]}`);
       if (result.errors.length > 1) {
-        logger.info("\nDetailed errors:");
+        logger.info("  Detailed errors:");
         for (const error of result.errors) {
-          logger.info(`  - ${error}`);
+          logger.info(`    - ${error}`);
         }
       }
+      logger.error(`
+\u274C Failed to import from ${tool}.`);
+      process.exit(1);
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5489,7 +6909,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path22 = require("path");
+var import_node_path29 = require("path");
 init_logger();
 async function initCommand(options = {}) {
   const configResult = await loadConfig();
@@ -5498,7 +6918,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_path29.join)(aiRulesDir, "rules");
   if (!useLegacy) {
     await ensureDir(rulesDir);
   }
@@ -5544,7 +6964,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path22.join)(rulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path29.join)(rulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     logger.success(`Created ${filepath}`);
@@ -5661,11 +7081,11 @@ async function watchCommand() {
     persistent: true
   });
   let isGenerating = false;
-  const handleChange = async (path5) => {
+  const handleChange = async (path8) => {
     if (isGenerating) return;
     isGenerating = true;
     logger.log(`
-\u{1F4DD} Detected change in ${path5}`);
+\u{1F4DD} Detected change in ${path8}`);
     try {
       await generateCommand({ verbose: false });
       logger.success("Regenerated configuration files");
@@ -5675,10 +7095,10 @@ async function watchCommand() {
       isGenerating = false;
     }
   };
-  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path5) => {
+  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path8) => {
     logger.log(`
-\u{1F5D1}\uFE0F  Removed ${path5}`);
-    handleChange(path5);
+\u{1F5D1}\uFE0F  Removed ${path8}`);
+    handleChange(path8);
   }).on("error", (error) => {
     logger.error("Watcher error:", error);
   });
@@ -5689,44 +7109,180 @@ async function watchCommand() {
   });
 }
 
+// src/cli/utils/targets-parser.ts
+init_logger();
+function parseTargets(targetsInput) {
+  if (!targetsInput) {
+    return [];
+  }
+  let targetStrings;
+  if (Array.isArray(targetsInput)) {
+    targetStrings = targetsInput;
+  } else {
+    targetStrings = targetsInput.split(",").map((target) => target.trim()).filter((target) => target.length > 0);
+  }
+  const results = [];
+  const errors = [];
+  let hasWildcard = false;
+  for (const targetString of targetStrings) {
+    if (targetString === "*" || targetString === "all") {
+      hasWildcard = true;
+      results.push(...ALL_TOOL_TARGETS);
+    } else if (isValidToolTarget(targetString)) {
+      results.push(targetString);
+    } else {
+      errors.push(targetString);
+    }
+  }
+  if (hasWildcard && targetStrings.length > 1) {
+    throw new Error(
+      "Cannot use '*' (all tools) with specific tool targets. Use either '--targets *' for all tools, or specify individual tools."
+    );
+  }
+  if (errors.length > 0) {
+    const validTargets = ALL_TOOL_TARGETS.join(", ");
+    throw new Error(
+      `Invalid tool targets: ${errors.join(", ")}. Valid targets are: ${validTargets}, *, all`
+    );
+  }
+  return [...new Set(results)];
+}
+function isValidToolTarget(target) {
+  return ALL_TOOL_TARGETS.includes(target);
+}
+function checkDeprecatedFlags(options) {
+  const deprecatedTools = [];
+  const flagToToolMap = {
+    agentsmd: "agentsmd",
+    amazonqcli: "amazonqcli",
+    augmentcode: "augmentcode",
+    "augmentcode-legacy": "augmentcode-legacy",
+    copilot: "copilot",
+    cursor: "cursor",
+    cline: "cline",
+    codexcli: "codexcli",
+    claudecode: "claudecode",
+    roo: "roo",
+    geminicli: "geminicli",
+    junie: "junie",
+    qwencode: "qwencode",
+    kiro: "kiro",
+    opencode: "opencode",
+    windsurf: "windsurf"
+  };
+  for (const [flag, tool] of Object.entries(flagToToolMap)) {
+    if (options[flag]) {
+      deprecatedTools.push(tool);
+    }
+  }
+  return deprecatedTools;
+}
+function getDeprecationWarning(deprecatedTools, command = "generate") {
+  const toolsStr = deprecatedTools.join(",");
+  return [
+    "\u26A0\uFE0F  DEPRECATED: Individual tool flags are deprecated and will be removed in a future version.",
+    `   Current: rulesync ${command} ${deprecatedTools.map((t) => `--${t}`).join(" ")}`,
+    `   New:     rulesync ${command} --targets ${toolsStr}`,
+    "   Please update your scripts to use the new --targets flag."
+  ].join("\n");
+}
+function mergeAndDeduplicateTools(targetsTools, deprecatedTools, allFlag) {
+  if (allFlag) {
+    logger.warn(
+      [
+        "\u26A0\uFE0F  DEPRECATED: The --all flag is deprecated and will be removed in a future version.",
+        "   Current: rulesync generate --all",
+        "   New:     rulesync generate --targets *",
+        "   Please update your scripts to use the new --targets flag."
+      ].join("\n")
+    );
+    return [...ALL_TOOL_TARGETS];
+  }
+  const allTools = [...targetsTools, ...deprecatedTools];
+  return [...new Set(allTools)];
+}
+
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.64.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.67.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("--opencode", "Import from OpenCode (AGENTS.md)").option("-v, --verbose", "Verbose output").option("--legacy", "Use legacy file location (.rulesync/*.md instead of .rulesync/rules/*.md)").action(importCommand);
-program.command("generate").description("Generate configuration files for AI tools").option("--augmentcode", "Generate only for AugmentCode").option("--augmentcode-legacy", "Generate only for AugmentCode legacy format").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--codexcli", "Generate only for OpenAI Codex CLI").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--junie", "Generate only for JetBrains Junie").option("--kiro", "Generate only for Kiro IDE").option("--opencode", "Generate only for OpenCode").option("--windsurf", "Generate only for Windsurf").option("--delete", "Delete all existing files in output directories before generating").option(
+program.command("import").description("Import configurations from AI tools to rulesync format").option("-t, --targets <tool>", "Tool to import from (e.g., 'copilot', 'cursor', 'cline')").option(
+  "--features <features>",
+  `Comma-separated list of features to import (${FEATURE_TYPES.join(",")}) or '*' for all`,
+  (value) => {
+    if (value === "*") return "*";
+    return value.split(",").map((f) => f.trim()).filter(Boolean);
+  }
+).option("--agentsmd", "[DEPRECATED] Import from AGENTS.md (use --targets agentsmd)").option("--augmentcode", "[DEPRECATED] Import from AugmentCode (use --targets augmentcode)").option(
+  "--augmentcode-legacy",
+  "[DEPRECATED] Import from AugmentCode legacy format (use --targets augmentcode-legacy)"
+).option("--claudecode", "[DEPRECATED] Import from Claude Code (use --targets claudecode)").option("--cursor", "[DEPRECATED] Import from Cursor (use --targets cursor)").option("--copilot", "[DEPRECATED] Import from GitHub Copilot (use --targets copilot)").option("--cline", "[DEPRECATED] Import from Cline (use --targets cline)").option("--roo", "[DEPRECATED] Import from Roo Code (use --targets roo)").option("--geminicli", "[DEPRECATED] Import from Gemini CLI (use --targets geminicli)").option("--junie", "[DEPRECATED] Import from JetBrains Junie (use --targets junie)").option("--qwencode", "[DEPRECATED] Import from Qwen Code (use --targets qwencode)").option("--opencode", "[DEPRECATED] Import from OpenCode (use --targets opencode)").option("-v, --verbose", "Verbose output").option("--legacy", "Use legacy file location (.rulesync/*.md instead of .rulesync/rules/*.md)").action(async (options) => {
+  try {
+    let tools = [];
+    const targetsTools = options.targets ? parseTargets(options.targets) : [];
+    const deprecatedTools = checkDeprecatedFlags(options);
+    if (deprecatedTools.length > 0) {
+      logger.warn(getDeprecationWarning(deprecatedTools, "import"));
+    }
+    tools = mergeAndDeduplicateTools(targetsTools, deprecatedTools, false);
+    const importOptions = {
+      ...tools.length > 0 && { targets: tools },
+      ...options.features && { features: options.features },
+      verbose: options.verbose,
+      legacy: options.legacy
+    };
+    await importCommand(importOptions);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+program.command("generate").description("Generate configuration files for AI tools").option("--all", "[DEPRECATED] Generate for all supported AI tools (use --targets * instead)").option(
+  "-t, --targets <tools>",
+  "Comma-separated list of tools to generate for (e.g., 'copilot,cursor,cline' or '*' for all)"
+).option(
+  "--features <features>",
+  `Comma-separated list of features to generate (${FEATURE_TYPES.join(",")}) or '*' for all`,
+  (value) => {
+    if (value === "*") return "*";
+    return value.split(",").map((f) => f.trim()).filter(Boolean);
+  }
+).option("--agentsmd", "[DEPRECATED] Generate only for AGENTS.md (use --targets agentsmd)").option(
+  "--amazonqcli",
+  "[DEPRECATED] Generate only for Amazon Q Developer CLI (use --targets amazonqcli)"
+).option("--augmentcode", "[DEPRECATED] Generate only for AugmentCode (use --targets augmentcode)").option(
+  "--augmentcode-legacy",
+  "[DEPRECATED] Generate only for AugmentCode legacy format (use --targets augmentcode-legacy)"
+).option("--copilot", "[DEPRECATED] Generate only for GitHub Copilot (use --targets copilot)").option("--cursor", "[DEPRECATED] Generate only for Cursor (use --targets cursor)").option("--cline", "[DEPRECATED] Generate only for Cline (use --targets cline)").option("--codexcli", "[DEPRECATED] Generate only for OpenAI Codex CLI (use --targets codexcli)").option("--claudecode", "[DEPRECATED] Generate only for Claude Code (use --targets claudecode)").option("--roo", "[DEPRECATED] Generate only for Roo Code (use --targets roo)").option("--geminicli", "[DEPRECATED] Generate only for Gemini CLI (use --targets geminicli)").option("--junie", "[DEPRECATED] Generate only for JetBrains Junie (use --targets junie)").option("--qwencode", "[DEPRECATED] Generate only for Qwen Code (use --targets qwencode)").option("--kiro", "[DEPRECATED] Generate only for Kiro IDE (use --targets kiro)").option("--opencode", "[DEPRECATED] Generate only for OpenCode (use --targets opencode)").option("--windsurf", "[DEPRECATED] Generate only for Windsurf (use --targets 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.opencode) tools.push("opencode");
-  if (options.windsurf) tools.push("windsurf");
-  const generateOptions = {
-    verbose: options.verbose,
-    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);
+  try {
+    let tools = [];
+    const targetsTools = options.targets ? parseTargets(options.targets) : [];
+    const deprecatedTools = checkDeprecatedFlags(options);
+    if (deprecatedTools.length > 0) {
+      logger.warn(getDeprecationWarning(deprecatedTools, "generate"));
+    }
+    tools = mergeAndDeduplicateTools(targetsTools, deprecatedTools, options.all === true);
+    const generateOptions = {
+      verbose: options.verbose,
+      tools: tools.length > 0 ? tools : void 0,
+      features: options.features,
+      delete: options.delete,
+      config: options.config,
+      noConfig: options.noConfig
+    };
+    if (options.baseDir) {
+      generateOptions.baseDirs = options.baseDir.split(",").map((dir) => dir.trim()).filter((dir) => dir.length > 0);
+    }
+    await generateCommand(generateOptions);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
-  await generateCommand(generateOptions);
 });
 program.command("validate").description("Validate rulesync configuration").action(validateCommand);
 program.command("status").description("Show current status of rulesync").action(statusCommand);