rulesync 0.49.0 → 0.52.0

package/dist/index.cjs

@@ -27,12 +27,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/types/tool-targets.ts
-var import_mini, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
+function isToolTarget(target) {
+  if (!target) return false;
+  return ALL_TOOL_TARGETS.some((validTarget) => validTarget === target);
+}
+var import_mini, ALL_TOOL_TARGETS, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
 var init_tool_targets = __esm({
   "src/types/tool-targets.ts"() {
     "use strict";
     import_mini = require("zod/mini");
-    ToolTargetSchema = import_mini.z.enum([
+    ALL_TOOL_TARGETS = [
       "augmentcode",
       "augmentcode-legacy",
       "copilot",
@@ -41,8 +45,10 @@ var init_tool_targets = __esm({
       "claudecode",
       "roo",
       "geminicli",
-      "kiro"
-    ]);
+      "kiro",
+      "junie"
+    ];
+    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]);
@@ -130,84 +136,108 @@ var init_augmentcode = __esm({
   }
 });
 
+// src/generators/mcp/shared-factory.ts
+function generateMcpConfig(config, toolConfig) {
+  const servers = {};
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, toolConfig.target)) continue;
+    servers[serverName] = toolConfig.serverTransform(server, serverName);
+  }
+  const finalConfig = toolConfig.configWrapper(servers);
+  return JSON.stringify(finalConfig, null, 2);
+}
+var configWrappers;
+var init_shared_factory = __esm({
+  "src/generators/mcp/shared-factory.ts"() {
+    "use strict";
+    init_mcp_helpers();
+    configWrappers = {
+      /**
+       * Standard mcpServers wrapper
+       */
+      mcpServers: (servers) => ({
+        mcpServers: servers
+      }),
+      /**
+       * Servers-only wrapper (for tools that use "servers" instead of "mcpServers")
+       */
+      servers: (servers) => ({
+        servers
+      })
+    };
+  }
+});
+
 // src/generators/mcp/claudecode.ts
 function generateClaudeMcp(config) {
-  const claudeSettings = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    return shouldIncludeServer(server, "claudecode");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const claudeServer = {};
-    if (server.command) {
-      claudeServer.command = server.command;
-      if (server.args) claudeServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        claudeServer.url = url;
+  return generateMcpConfig(config, {
+    target: "claudecode",
+    configPaths: [".claude/settings.json"],
+    serverTransform: (server) => {
+      const claudeServer = {};
+      if (server.command) {
+        claudeServer.command = server.command;
+        if (server.args) claudeServer.args = server.args;
+      } else if (server.url || server.httpUrl) {
+        const url = server.httpUrl || server.url;
+        if (url) {
+          claudeServer.url = url;
+        }
+        if (server.httpUrl) {
+          claudeServer.transport = "http";
+        } else if (server.transport === "sse") {
+          claudeServer.transport = "sse";
+        }
       }
-      if (server.httpUrl) {
-        claudeServer.transport = "http";
-      } else if (server.transport === "sse") {
-        claudeServer.transport = "sse";
+      if (server.env) {
+        claudeServer.env = server.env;
       }
-    }
-    if (server.env) {
-      claudeServer.env = server.env;
-    }
-    if (claudeSettings.mcpServers) {
-      claudeSettings.mcpServers[serverName] = claudeServer;
-    }
-  }
-  return JSON.stringify(claudeSettings, null, 2);
+      return claudeServer;
+    },
+    configWrapper: configWrappers.mcpServers
+  });
 }
 var init_claudecode = __esm({
   "src/generators/mcp/claudecode.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
 // src/generators/mcp/cline.ts
 function generateClineMcp(config) {
-  const clineConfig = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    return shouldIncludeServer(server, "cline");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const clineServer = {};
-    if (server.command) {
-      clineServer.command = server.command;
-      if (server.args) clineServer.args = server.args;
-    } else if (server.url) {
-      clineServer.url = server.url;
-    }
-    if (server.env) {
-      clineServer.env = server.env;
-    }
-    if (server.disabled !== void 0) {
-      clineServer.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      clineServer.alwaysAllow = server.alwaysAllow;
-    }
-    if (server.networkTimeout !== void 0) {
-      clineServer.networkTimeout = server.networkTimeout;
-    }
-    clineConfig.mcpServers[serverName] = clineServer;
-  }
-  return JSON.stringify(clineConfig, null, 2);
+  return generateMcpConfig(config, {
+    target: "cline",
+    configPaths: [".cline/mcp.json"],
+    serverTransform: (server) => {
+      const clineServer = {};
+      if (server.command) {
+        clineServer.command = server.command;
+        if (server.args) clineServer.args = server.args;
+      } else if (server.url) {
+        clineServer.url = server.url;
+      }
+      if (server.env) {
+        clineServer.env = server.env;
+      }
+      if (server.disabled !== void 0) {
+        clineServer.disabled = server.disabled;
+      }
+      if (server.alwaysAllow) {
+        clineServer.alwaysAllow = server.alwaysAllow;
+      }
+      if (server.networkTimeout !== void 0) {
+        clineServer.networkTimeout = server.networkTimeout;
+      }
+      return clineServer;
+    },
+    configWrapper: configWrappers.mcpServers
+  });
 }
 var init_cline = __esm({
   "src/generators/mcp/cline.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
@@ -354,6 +384,58 @@ var init_geminicli = __esm({
   }
 });
 
+// src/generators/mcp/junie.ts
+function generateJunieMcp(config) {
+  const junieConfig = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "junie")) continue;
+    const junieServer = {
+      name: serverName
+    };
+    if (server.command) {
+      junieServer.command = server.command;
+      if (server.args) junieServer.args = server.args;
+    } else if (server.url || server.httpUrl) {
+      if (server.httpUrl) {
+        junieServer.httpUrl = server.httpUrl;
+      } else if (server.url) {
+        junieServer.url = server.url;
+      }
+    }
+    if (server.env) {
+      junieServer.env = server.env;
+    }
+    if (server.cwd) {
+      junieServer.workingDirectory = server.cwd;
+    }
+    if (server.timeout !== void 0) {
+      junieServer.timeout = server.timeout;
+    }
+    if (server.trust !== void 0) {
+      junieServer.trust = server.trust;
+    }
+    if (server.transport) {
+      if (String(server.transport) === "streamable-http") {
+        junieServer.transport = "http";
+      } else if (server.transport === "stdio" || server.transport === "http" || server.transport === "sse") {
+        junieServer.transport = server.transport;
+      }
+    } else if (server.command) {
+      junieServer.transport = "stdio";
+    }
+    junieConfig.mcpServers[serverName] = junieServer;
+  }
+  return JSON.stringify(junieConfig, null, 2);
+}
+var init_junie = __esm({
+  "src/generators/mcp/junie.ts"() {
+    "use strict";
+    init_mcp_helpers();
+  }
+});
+
 // src/generators/mcp/kiro.ts
 function generateKiroMcp(config) {
   const kiroConfig = {
@@ -478,19 +560,11 @@ function getDefaultConfig() {
       claudecode: ".",
       roo: ".roo/rules",
       geminicli: ".gemini/memories",
-      kiro: ".kiro/steering"
+      kiro: ".kiro/steering",
+      junie: "."
     },
     watchEnabled: false,
-    defaultTargets: [
-      "augmentcode",
-      "copilot",
-      "cursor",
-      "cline",
-      "claudecode",
-      "roo",
-      "geminicli",
-      "kiro"
-    ]
+    defaultTargets: ALL_TOOL_TARGETS.filter((tool) => tool !== "augmentcode-legacy")
   };
 }
 function resolveTargets(targets, config) {
@@ -537,267 +611,643 @@ async function addCommand(filename) {
   }
 }
 
-// src/generators/ignore/augmentcode.ts
-var import_node_path = require("path");
-async function generateAugmentCodeIgnoreFiles(rules, config, baseDir) {
-  const outputs = [];
-  const augmentignoreContent = generateAugmentignoreContent(rules);
-  const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path.join)(outputPath, ".augmentignore");
-  outputs.push({
-    tool: "augmentcode",
-    filepath,
-    content: augmentignoreContent
-  });
-  return outputs;
-}
-function generateAugmentignoreContent(rules) {
-  const lines = [
-    "# Generated by rulesync - AugmentCode ignore patterns",
-    "# AugmentCode uses a two-tier approach: .gitignore first, then .augmentignore",
-    "# This file provides Augment-specific exclusions and re-inclusions",
-    ""
-  ];
-  lines.push(
-    "# Security and Secrets (critical exclusions)",
-    "# Environment files",
-    ".env*",
-    "",
-    "# Private keys and certificates",
-    "*.pem",
-    "*.key",
-    "*.p12",
-    "*.crt",
-    "*.der",
-    "",
-    "# SSH keys",
-    "id_rsa*",
-    "id_dsa*",
-    "",
-    "# AWS credentials",
-    ".aws/",
-    "aws-exports.js",
-    "",
-    "# API keys and tokens",
-    "**/apikeys/",
-    "**/*_token*",
-    "**/*_secret*",
-    ""
-  );
-  lines.push(
-    "# Build Artifacts and Dependencies",
-    "# Build outputs",
-    "dist/",
-    "build/",
-    "out/",
-    "target/",
-    "",
-    "# Dependencies",
-    "node_modules/",
-    "venv/",
-    "*.egg-info/",
-    "",
-    "# Logs",
-    "*.log",
-    "logs/",
-    "",
-    "# Temporary files",
-    "*.tmp",
-    "*.swp",
-    "*.swo",
-    "*~",
-    ""
-  );
-  lines.push(
-    "# Large Files and Media",
-    "# Binary files",
-    "*.jar",
-    "*.png",
-    "*.jpg",
-    "*.jpeg",
-    "*.gif",
-    "*.mp4",
-    "*.avi",
-    "*.zip",
-    "*.tar.gz",
-    "*.rar",
-    "",
-    "# Database files",
-    "*.sqlite",
-    "*.db",
-    "*.mdb",
-    "",
-    "# Data files",
-    "*.csv",
-    "*.tsv",
-    "*.xlsx",
-    ""
-  );
-  lines.push(
-    "# Performance Optimization",
-    "# Exclude files that are too large for effective AI processing",
-    "**/*.{mp4,avi,mov,mkv}",
-    "**/*.{zip,tar,gz,rar}",
-    "**/*.{pdf,doc,docx}",
-    "**/logs/**/*.log",
-    "",
-    "# But include small configuration files",
-    "!**/config.{json,yaml,yml}",
-    ""
-  );
-  const rulePatterns = extractIgnorePatternsFromRules(rules);
-  if (rulePatterns.length > 0) {
-    lines.push("# Project-specific patterns from rulesync rules");
-    lines.push(...rulePatterns);
-    lines.push("");
+// src/cli/commands/config.ts
+var import_node_fs = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/types/claudecode.ts
+var import_mini2 = require("zod/mini");
+var ClaudeSettingsSchema = import_mini2.z.looseObject({
+  permissions: import_mini2.z._default(
+    import_mini2.z.looseObject({
+      deny: import_mini2.z._default(import_mini2.z.array(import_mini2.z.string()), [])
+    }),
+    { deny: [] }
+  )
+});
+
+// src/types/config.ts
+var import_mini3 = require("zod/mini");
+init_tool_targets();
+var ConfigSchema = import_mini3.z.object({
+  aiRulesDir: import_mini3.z.string(),
+  outputPaths: import_mini3.z.record(ToolTargetSchema, import_mini3.z.string()),
+  watchEnabled: import_mini3.z.boolean(),
+  defaultTargets: ToolTargetsSchema
+});
+
+// src/types/config-options.ts
+var import_mini4 = require("zod/mini");
+init_tool_targets();
+var OutputPathsSchema = import_mini4.z.object({
+  augmentcode: import_mini4.z.optional(import_mini4.z.string()),
+  "augmentcode-legacy": import_mini4.z.optional(import_mini4.z.string()),
+  copilot: import_mini4.z.optional(import_mini4.z.string()),
+  cursor: import_mini4.z.optional(import_mini4.z.string()),
+  cline: import_mini4.z.optional(import_mini4.z.string()),
+  claudecode: import_mini4.z.optional(import_mini4.z.string()),
+  roo: import_mini4.z.optional(import_mini4.z.string()),
+  geminicli: import_mini4.z.optional(import_mini4.z.string()),
+  kiro: import_mini4.z.optional(import_mini4.z.string()),
+  junie: import_mini4.z.optional(import_mini4.z.string())
+});
+var ConfigOptionsSchema = import_mini4.z.object({
+  aiRulesDir: import_mini4.z.optional(import_mini4.z.string()),
+  outputPaths: import_mini4.z.optional(OutputPathsSchema),
+  watchEnabled: import_mini4.z.optional(import_mini4.z.boolean()),
+  defaultTargets: import_mini4.z.optional(ToolTargetsSchema),
+  targets: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
+  exclude: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
+  verbose: import_mini4.z.optional(import_mini4.z.boolean()),
+  delete: import_mini4.z.optional(import_mini4.z.boolean()),
+  baseDir: import_mini4.z.optional(import_mini4.z.union([import_mini4.z.string(), import_mini4.z.array(import_mini4.z.string())])),
+  watch: import_mini4.z.optional(
+    import_mini4.z.object({
+      enabled: import_mini4.z.optional(import_mini4.z.boolean()),
+      interval: import_mini4.z.optional(import_mini4.z.number()),
+      ignore: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
+    })
+  )
+});
+var MergedConfigSchema = 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,
+  targets: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
+  exclude: import_mini4.z.optional(import_mini4.z.array(ToolTargetSchema)),
+  verbose: import_mini4.z.optional(import_mini4.z.boolean()),
+  delete: import_mini4.z.optional(import_mini4.z.boolean()),
+  baseDir: import_mini4.z.optional(import_mini4.z.union([import_mini4.z.string(), import_mini4.z.array(import_mini4.z.string())])),
+  configPath: import_mini4.z.optional(import_mini4.z.string()),
+  watch: import_mini4.z.optional(
+    import_mini4.z.object({
+      enabled: import_mini4.z.optional(import_mini4.z.boolean()),
+      interval: import_mini4.z.optional(import_mini4.z.number()),
+      ignore: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
+    })
+  )
+});
+
+// src/types/mcp.ts
+var import_mini5 = require("zod/mini");
+init_tool_targets();
+var McpTransportTypeSchema = import_mini5.z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = import_mini5.z.object({
+  command: import_mini5.z.optional(import_mini5.z.string()),
+  args: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
+  url: import_mini5.z.optional(import_mini5.z.string()),
+  httpUrl: import_mini5.z.optional(import_mini5.z.string()),
+  env: import_mini5.z.optional(import_mini5.z.record(import_mini5.z.string(), import_mini5.z.string())),
+  disabled: import_mini5.z.optional(import_mini5.z.boolean()),
+  networkTimeout: import_mini5.z.optional(import_mini5.z.number()),
+  timeout: import_mini5.z.optional(import_mini5.z.number()),
+  trust: import_mini5.z.optional(import_mini5.z.boolean()),
+  cwd: import_mini5.z.optional(import_mini5.z.string()),
+  transport: import_mini5.z.optional(McpTransportTypeSchema),
+  type: import_mini5.z.optional(import_mini5.z.enum(["sse", "streamable-http"])),
+  alwaysAllow: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
+  tools: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
+  kiroAutoApprove: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string())),
+  kiroAutoBlock: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
+});
+var RulesyncMcpServerSchema = import_mini5.z.extend(McpServerBaseSchema, {
+  targets: import_mini5.z.optional(RulesyncTargetsSchema)
+});
+var McpConfigSchema = import_mini5.z.object({
+  mcpServers: import_mini5.z.record(import_mini5.z.string(), McpServerBaseSchema)
+});
+var RulesyncMcpConfigSchema = import_mini5.z.object({
+  mcpServers: import_mini5.z.record(import_mini5.z.string(), RulesyncMcpServerSchema)
+});
+
+// src/types/rules.ts
+var import_mini6 = require("zod/mini");
+init_tool_targets();
+var RuleFrontmatterSchema = import_mini6.z.object({
+  root: import_mini6.z.boolean(),
+  targets: RulesyncTargetsSchema,
+  description: import_mini6.z.string(),
+  globs: import_mini6.z.array(import_mini6.z.string()),
+  cursorRuleType: import_mini6.z.optional(import_mini6.z.enum(["always", "manual", "specificFiles", "intelligently"])),
+  tags: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string()))
+});
+var ParsedRuleSchema = import_mini6.z.object({
+  frontmatter: RuleFrontmatterSchema,
+  content: import_mini6.z.string(),
+  filename: import_mini6.z.string(),
+  filepath: import_mini6.z.string()
+});
+var GeneratedOutputSchema = import_mini6.z.object({
+  tool: ToolTargetSchema,
+  filepath: import_mini6.z.string(),
+  content: import_mini6.z.string()
+});
+var GenerateOptionsSchema = import_mini6.z.object({
+  targetTools: import_mini6.z.optional(ToolTargetsSchema),
+  outputDir: import_mini6.z.optional(import_mini6.z.string()),
+  watch: import_mini6.z.optional(import_mini6.z.boolean())
+});
+
+// src/types/index.ts
+init_tool_targets();
+
+// src/utils/config-loader.ts
+var import_c12 = require("c12");
+var import_core = require("zod/v4/core");
+var MODULE_NAME = "rulesync";
+async function loadConfig(options = {}) {
+  const defaultConfig = getDefaultConfig();
+  if (options.noConfig) {
+    return {
+      config: defaultConfig,
+      isEmpty: true
+    };
   }
-  lines.push(
-    "# Team Collaboration",
-    "# Exclude personal IDE settings",
-    ".vscode/settings.json",
-    ".idea/workspace.xml",
-    "",
-    "# But include shared team settings",
-    "!.vscode/extensions.json",
-    "!.idea/codeStyles/",
-    "",
-    "# Exclude test fixtures with sensitive data",
-    "tests/fixtures/real-data/**",
-    "",
-    "# Re-include important documentation",
-    "!vendor/*/README.md",
-    "!third-party/*/LICENSE",
-    ""
-  );
-  return lines.join("\n");
-}
-function extractIgnorePatternsFromRules(rules) {
-  const patterns = [];
-  for (const rule of rules) {
-    if (rule.frontmatter.globs && rule.frontmatter.globs.length > 0) {
-      for (const glob of rule.frontmatter.globs) {
-        if (shouldExcludeFromAugmentCode(glob)) {
-          patterns.push(`# Exclude: ${rule.frontmatter.description}`);
-          patterns.push(glob);
-        }
+  try {
+    const loadOptions = {
+      name: MODULE_NAME,
+      cwd: options.cwd || process.cwd(),
+      rcFile: false,
+      // Disable rc file lookup
+      configFile: "rulesync",
+      // Will look for rulesync.jsonc, rulesync.ts, etc.
+      defaults: defaultConfig
+    };
+    if (options.configPath) {
+      loadOptions.configFile = options.configPath;
+    }
+    const { config, configFile } = await (0, import_c12.loadConfig)(loadOptions);
+    if (!config || Object.keys(config).length === 0) {
+      return {
+        config: defaultConfig,
+        isEmpty: true
+      };
+    }
+    try {
+      ConfigOptionsSchema.parse(config);
+    } catch (error) {
+      if (error instanceof import_core.$ZodError) {
+        const issues = error.issues.map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`).join("\n");
+        throw new Error(`Invalid configuration in ${configFile}:
+${issues}`);
       }
+      throw error;
     }
-    const contentPatterns = extractAugmentCodeIgnorePatternsFromContent(rule.content);
-    patterns.push(...contentPatterns);
+    const processedConfig = postProcessConfig(config);
+    const result = {
+      config: processedConfig,
+      isEmpty: false
+    };
+    if (configFile) {
+      result.filepath = configFile;
+    }
+    return result;
+  } catch (error) {
+    throw new Error(
+      `Failed to load configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
-  return patterns;
 }
-function shouldExcludeFromAugmentCode(glob) {
-  const excludePatterns = [
-    // Large generated files that slow indexing
-    "**/assets/generated/**",
-    "**/public/build/**",
-    // Test fixtures with potentially sensitive data
-    "**/tests/fixtures/**",
-    "**/test/fixtures/**",
-    "**/*.fixture.*",
-    // Build outputs that provide little value for AI context
-    "**/dist/**",
-    "**/build/**",
-    "**/coverage/**",
-    // Configuration that might contain sensitive data
-    "**/config/production/**",
-    "**/config/secrets/**",
-    "**/deploy/prod/**",
-    // Internal documentation
-    "**/internal-docs/**",
-    "**/proprietary/**",
-    "**/personal-notes/**",
-    "**/private/**",
-    "**/confidential/**"
-  ];
-  return excludePatterns.some((pattern) => {
-    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
-    return regex.test(glob);
-  });
+function postProcessConfig(config) {
+  const processed = { ...config };
+  if (processed.baseDir && !Array.isArray(processed.baseDir)) {
+    processed.baseDir = [processed.baseDir];
+  }
+  if (config.targets || config.exclude) {
+    const baseTargets = config.targets || processed.defaultTargets;
+    if (config.exclude && config.exclude.length > 0) {
+      processed.defaultTargets = baseTargets.filter(
+        (target) => config.exclude && !config.exclude.includes(target)
+      );
+    } else {
+      processed.defaultTargets = baseTargets;
+    }
+  }
+  return processed;
 }
-function extractAugmentCodeIgnorePatternsFromContent(content) {
-  const patterns = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("# AUGMENT_IGNORE:") || trimmed.startsWith("# augmentignore:")) {
-      const pattern = trimmed.replace(/^# (AUGMENT_IGNORE|augmentignore):\s*/, "").trim();
-      if (pattern) {
-        patterns.push(pattern);
+function generateMinimalConfig(options) {
+  if (!options || Object.keys(options).length === 0) {
+    return generateSampleConfig();
+  }
+  const lines = ["{"];
+  if (options.targets || options.exclude) {
+    lines.push(`  // Available tools: ${ALL_TOOL_TARGETS.join(", ")}`);
+  }
+  if (options.targets) {
+    lines.push(`  "targets": ${JSON.stringify(options.targets)}`);
+  }
+  if (options.exclude) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "exclude": ${JSON.stringify(options.exclude)}`);
+  }
+  if (options.aiRulesDir) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "aiRulesDir": "${options.aiRulesDir}"`);
+  }
+  if (options.outputPaths) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(
+      `  "outputPaths": ${JSON.stringify(options.outputPaths, null, 4).split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n")}`
+    );
+  }
+  if (options.baseDir) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "baseDir": ${JSON.stringify(options.baseDir)}`);
+  }
+  if (options.delete !== void 0) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "delete": ${options.delete}`);
+  }
+  if (options.verbose !== void 0) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(`  "verbose": ${options.verbose}`);
+  }
+  if (options.watch) {
+    const comma = lines.length > 1 ? "," : "";
+    if (comma) lines[lines.length - 1] += comma;
+    lines.push(
+      `  "watch": ${JSON.stringify(options.watch, null, 4).split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n")}`
+    );
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function generateSampleConfig(options) {
+  const targets = options?.targets || ALL_TOOL_TARGETS;
+  const excludeValue = options?.exclude ? JSON.stringify(options.exclude) : null;
+  const aiRulesDir = options?.aiRulesDir || null;
+  const baseDir = options?.baseDir || null;
+  const deleteFlag = options?.delete || false;
+  const verbose = options?.verbose !== void 0 ? options.verbose : true;
+  return `{
+  // List of tools to generate configurations for
+  // Available: ${ALL_TOOL_TARGETS.join(", ")}
+  "targets": ${JSON.stringify(targets)},
+  
+  // Tools to exclude from generation (overrides targets)
+  ${excludeValue ? `"exclude": ${excludeValue},` : '// "exclude": ["roo"],'}
+  ${aiRulesDir ? `
+  // Directory containing AI rule files
+  "aiRulesDir": "${aiRulesDir}",` : ""}
+  
+  // Custom output paths for specific tools
+  "outputPaths": {
+    "copilot": ".github/copilot-instructions.md"
+  },
+  ${baseDir ? `
+  // Base directory for generation
+  "baseDir": "${baseDir}",` : `
+  // Base directory or directories for generation
+  // "baseDir": "./packages",
+  // "baseDir": ["./packages/frontend", "./packages/backend"],`}
+  
+  // Delete existing files before generating
+  "delete": ${deleteFlag},
+  
+  // Enable verbose output
+  "verbose": ${verbose},
+  
+  // Watch configuration
+  "watch": {
+    "enabled": false,
+    "interval": 1000,
+    "ignore": ["node_modules/**", "dist/**"]
+  }
+}
+`;
+}
+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/utils/file.ts
+var import_promises2 = require("fs/promises");
+var import_node_path = require("path");
+async function ensureDir(dirPath) {
+  try {
+    await (0, import_promises2.stat)(dirPath);
+  } catch {
+    await (0, import_promises2.mkdir)(dirPath, { recursive: true });
+  }
+}
+async function readFileContent(filepath) {
+  return (0, import_promises2.readFile)(filepath, "utf-8");
+}
+async function writeFileContent(filepath, content) {
+  await ensureDir((0, import_node_path.dirname)(filepath));
+  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
+}
+async function fileExists(filepath) {
+  try {
+    await (0, import_promises2.stat)(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findFiles(dir, extension = ".md") {
+  try {
+    const files = await (0, import_promises2.readdir)(dir);
+    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path.join)(dir, file));
+  } catch {
+    return [];
+  }
+}
+async function removeDirectory(dirPath) {
+  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
+  if (dangerousPaths.includes(dirPath) || dirPath === "") {
+    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.warn(`Failed to remove directory ${dirPath}:`, error);
+  }
+}
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await (0, import_promises2.rm)(filepath);
+    }
+  } catch (error) {
+    console.warn(`Failed to remove file ${filepath}:`, error);
+  }
+}
+async function removeClaudeGeneratedFiles() {
+  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
+  for (const fileOrDir of filesToRemove) {
+    if (fileOrDir.endsWith("/memories")) {
+      await removeDirectory(fileOrDir);
+    } else {
+      await removeFile(fileOrDir);
+    }
+  }
+}
+
+// src/utils/rules.ts
+function isToolSpecificRule(rule, targetTool) {
+  const filename = rule.filename;
+  const toolPatterns = {
+    "augmentcode-legacy": /^specification-augmentcode-legacy-/i,
+    augmentcode: /^specification-augmentcode-/i,
+    copilot: /^specification-copilot-/i,
+    cursor: /^specification-cursor-/i,
+    cline: /^specification-cline-/i,
+    claudecode: /^specification-claudecode-/i,
+    roo: /^specification-roo-/i,
+    geminicli: /^specification-geminicli-/i,
+    kiro: /^specification-kiro-/i
+  };
+  for (const [tool, pattern] of Object.entries(toolPatterns)) {
+    if (pattern.test(filename)) {
+      return tool === targetTool;
+    }
+  }
+  return true;
+}
+
+// src/cli/commands/config.ts
+async function configCommand(options = {}) {
+  if (options.init) {
+    await initConfig(options);
+    return;
+  }
+  await showConfig();
+}
+async function showConfig() {
+  console.log("Loading configuration...\n");
+  try {
+    const result = await loadConfig();
+    if (result.isEmpty) {
+      console.log("No configuration file found. Using default configuration.\n");
+    } else {
+      console.log(`Configuration loaded from: ${result.filepath}
+`);
+    }
+    console.log("Current configuration:");
+    console.log("=====================");
+    const config = result.config;
+    console.log(`
+AI Rules Directory: ${config.aiRulesDir}`);
+    console.log(`
+Default Targets: ${config.defaultTargets.join(", ")}`);
+    if (config.exclude && config.exclude.length > 0) {
+      console.log(`Excluded Targets: ${config.exclude.join(", ")}`);
+    }
+    console.log("\nOutput Paths:");
+    for (const [tool, outputPath] of Object.entries(config.outputPaths)) {
+      console.log(`  ${tool}: ${outputPath}`);
+    }
+    if (config.baseDir) {
+      const dirs = Array.isArray(config.baseDir) ? config.baseDir : [config.baseDir];
+      console.log(`
+Base Directories: ${dirs.join(", ")}`);
+    }
+    console.log(`
+Verbose: ${config.verbose || false}`);
+    console.log(`Delete before generate: ${config.delete || false}`);
+    if (config.watch) {
+      console.log("\nWatch Configuration:");
+      console.log(`  Enabled: ${config.watch.enabled || false}`);
+      if (config.watch.interval) {
+        console.log(`  Interval: ${config.watch.interval}ms`);
+      }
+      if (config.watch.ignore && config.watch.ignore.length > 0) {
+        console.log(`  Ignore patterns: ${config.watch.ignore.join(", ")}`);
       }
     }
-    if (trimmed.startsWith("# AUGMENT_INCLUDE:") || trimmed.startsWith("# augmentinclude:")) {
-      const pattern = trimmed.replace(/^# (AUGMENT_INCLUDE|augmentinclude):\s*/, "").trim();
-      if (pattern) {
-        patterns.push(`!${pattern}`);
+    console.log("\nTip: Use 'rulesync config init' to create a configuration file.");
+  } catch (error) {
+    console.error(
+      "\u274C Failed to load configuration:",
+      error instanceof Error ? error.message : String(error)
+    );
+    process.exit(1);
+  }
+}
+var FORMAT_CONFIG = {
+  jsonc: {
+    filename: "rulesync.jsonc",
+    generator: generateJsoncConfig
+  },
+  ts: {
+    filename: "rulesync.ts",
+    generator: generateTsConfig
+  }
+};
+async function initConfig(options) {
+  const validFormats = Object.keys(FORMAT_CONFIG);
+  const selectedFormat = options.format || "jsonc";
+  if (!validFormats.includes(selectedFormat)) {
+    console.error(
+      `\u274C Invalid format: ${selectedFormat}. Valid formats are: ${validFormats.join(", ")}`
+    );
+    process.exit(1);
+  }
+  const formatConfig = FORMAT_CONFIG[selectedFormat];
+  const filename = formatConfig.filename;
+  const configOptions = {};
+  if (options.targets) {
+    const targets = options.targets.split(",").map((t) => t.trim());
+    const validTargets = [];
+    for (const target of targets) {
+      const result = ToolTargetSchema.safeParse(target);
+      if (result.success) {
+        validTargets.push(result.data);
+      } else {
+        console.error(`\u274C Invalid target: ${target}`);
+        process.exit(1);
       }
     }
-    if (trimmed.includes("large file") || trimmed.includes("binary") || trimmed.includes("media")) {
-      const matches = trimmed.match(/['"`]([^'"`]+\.(mp4|avi|zip|tar\.gz|rar|pdf|doc|xlsx))['"`]/g);
-      if (matches) {
-        patterns.push(...matches.map((m) => m.replace(/['"`]/g, "")));
+    configOptions.targets = validTargets;
+  }
+  if (options.exclude) {
+    const excludes = options.exclude.split(",").map((t) => t.trim());
+    const validExcludes = [];
+    for (const exclude of excludes) {
+      const result = ToolTargetSchema.safeParse(exclude);
+      if (result.success) {
+        validExcludes.push(result.data);
+      } else {
+        console.error(`\u274C Invalid exclude target: ${exclude}`);
+        process.exit(1);
       }
     }
+    configOptions.exclude = validExcludes;
+  }
+  if (options.aiRulesDir) {
+    configOptions.aiRulesDir = options.aiRulesDir;
+  }
+  if (options.baseDir) {
+    configOptions.baseDir = options.baseDir;
+  }
+  if (options.verbose !== void 0) {
+    configOptions.verbose = options.verbose;
+  }
+  if (options.delete !== void 0) {
+    configOptions.delete = options.delete;
+  }
+  const content = formatConfig.generator(configOptions);
+  const filepath = import_node_path2.default.join(process.cwd(), filename);
+  try {
+    const fs2 = await import("fs/promises");
+    await fs2.access(filepath);
+    console.error(`\u274C Configuration file already exists: ${filepath}`);
+    console.log("Remove the existing file or choose a different format.");
+    process.exit(1);
+  } catch {
+  }
+  try {
+    (0, import_node_fs.writeFileSync)(filepath, content, "utf-8");
+    console.log(`\u2705 Created configuration file: ${filepath}`);
+    console.log("\nYou can now customize the configuration to fit your needs.");
+    console.log("Run 'rulesync generate' to use the new configuration.");
+  } catch (error) {
+    console.error(
+      `\u274C Failed to create configuration file: ${error instanceof Error ? error.message : String(error)}`
+    );
+    process.exit(1);
   }
-  return patterns;
 }
+function generateJsoncConfig(options) {
+  if (options && Object.keys(options).length > 0) {
+    return generateMinimalConfig(options);
+  }
+  return generateSampleConfig(options);
+}
+function generateTsConfig(options) {
+  if (!options || Object.keys(options).length === 0) {
+    return `import type { ConfigOptions } from "rulesync";
+
+const config: ConfigOptions = {
+  // List of tools to generate configurations for
+  // Available: ${ALL_TOOL_TARGETS.join(", ")}
+  targets: ${JSON.stringify(ALL_TOOL_TARGETS)},
+  
+  // Custom output paths for specific tools
+  // outputPaths: {
+  //   copilot: ".github/copilot-instructions.md",
+  // },
+  
+  // Delete existing files before generating
+  // delete: false,
+  
+  // Enable verbose output
+  verbose: true,
+};
 
-// src/generators/ignore/kiro.ts
-var import_node_path2 = require("path");
-async function generateKiroIgnoreFiles(rules, config, baseDir) {
-  const outputs = [];
-  const aiignoreContent = generateAiignoreContent(rules);
-  const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path2.join)(outputPath, ".aiignore");
-  outputs.push({
-    tool: "kiro",
-    filepath,
-    content: aiignoreContent
-  });
-  return outputs;
-}
-function generateAiignoreContent(rules) {
-  const lines = [
-    "# Generated by rulesync - Kiro AI-specific exclusions",
-    "# This file excludes files that can be in Git but shouldn't be read by the AI",
-    ""
-  ];
-  lines.push(
-    "# Data files AI shouldn't process",
-    "*.csv",
-    "*.tsv",
-    "*.sqlite",
-    "*.db",
-    "",
-    "# Large binary files",
-    "*.zip",
-    "*.tar.gz",
-    "*.rar",
-    "",
-    "# Sensitive documentation",
-    "internal-docs/",
-    "confidential/",
-    "",
-    "# Test data that might confuse AI",
-    "test/fixtures/large-*.json",
-    "benchmark-results/",
-    "",
-    "# Reinforce critical exclusions from .gitignore",
-    "*.pem",
-    "*.key",
-    ".env*",
-    ""
-  );
-  const rulePatterns = extractIgnorePatternsFromRules2(rules);
-  if (rulePatterns.length > 0) {
-    lines.push("# Project-specific exclusions from rulesync rules");
-    lines.push(...rulePatterns);
-    lines.push("");
+export default config;`;
   }
-  return lines.join("\n");
+  const configLines = [];
+  if (options.targets) {
+    configLines.push(`  targets: ${JSON.stringify(options.targets)}`);
+  }
+  if (options.exclude) {
+    configLines.push(`  exclude: ${JSON.stringify(options.exclude)}`);
+  }
+  if (options.aiRulesDir) {
+    configLines.push(`  aiRulesDir: "${options.aiRulesDir}"`);
+  }
+  if (options.outputPaths) {
+    const pathsStr = JSON.stringify(options.outputPaths, null, 4).split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n");
+    configLines.push(`  outputPaths: ${pathsStr}`);
+  }
+  if (options.baseDir) {
+    configLines.push(`  baseDir: ${JSON.stringify(options.baseDir)}`);
+  }
+  if (options.delete !== void 0) {
+    configLines.push(`  delete: ${options.delete}`);
+  }
+  if (options.verbose !== void 0) {
+    configLines.push(`  verbose: ${options.verbose}`);
+  }
+  if (options.watch) {
+    const watchStr = JSON.stringify(options.watch, null, 4).split("\n").map((line, i) => i === 0 ? line : `  ${line}`).join("\n");
+    configLines.push(`  watch: ${watchStr}`);
+  }
+  const configContent = `import type { ConfigOptions } from "rulesync";
+
+const config: ConfigOptions = {
+${configLines.join(",\n")},
+};
+
+export default config;
+`;
+  return configContent;
 }
-function extractIgnorePatternsFromRules2(rules) {
+
+// src/cli/commands/generate.ts
+var import_node_path12 = require("path");
+
+// src/generators/ignore/shared-factory.ts
+var import_node_path3 = require("path");
+
+// src/generators/ignore/shared-helpers.ts
+function extractIgnorePatternsFromRules(rules) {
   const patterns = [];
   for (const rule of rules) {
     if (rule.frontmatter.globs && rule.frontmatter.globs.length > 0) {
@@ -815,20 +1265,28 @@ function extractIgnorePatternsFromRules2(rules) {
 }
 function shouldExcludeFromAI(glob) {
   const excludePatterns = [
-    // Test and fixture files that might be large or confusing
-    "**/test/fixtures/**",
+    // Large generated files that slow indexing
+    "**/assets/generated/**",
+    "**/public/build/**",
+    // Test fixtures with potentially sensitive data
     "**/tests/fixtures/**",
+    "**/test/fixtures/**",
     "**/*.fixture.*",
-    // Build and generated files
+    // Build outputs that provide little value for AI context
     "**/dist/**",
     "**/build/**",
     "**/coverage/**",
     // Configuration that might contain sensitive data
     "**/config/production/**",
+    "**/config/secrets/**",
     "**/config/prod/**",
+    "**/deploy/prod/**",
     "**/*.prod.*",
-    // Documentation that might be sensitive
+    // Internal documentation that might be sensitive
     "**/internal/**",
+    "**/internal-docs/**",
+    "**/proprietary/**",
+    "**/personal-notes/**",
     "**/private/**",
     "**/confidential/**"
   ];
@@ -848,6 +1306,18 @@ function extractIgnorePatternsFromContent(content) {
         patterns.push(pattern);
       }
     }
+    if (trimmed.startsWith("# AUGMENT_IGNORE:") || trimmed.startsWith("# augmentignore:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_IGNORE|augmentignore):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+    if (trimmed.startsWith("# AUGMENT_INCLUDE:") || trimmed.startsWith("# augmentinclude:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_INCLUDE|augmentinclude):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(`!${pattern}`);
+      }
+    }
     if (trimmed.includes("exclude") || trimmed.includes("ignore")) {
       const matches = trimmed.match(/['"`]([^'"`]+\.(log|tmp|cache|temp))['"`]/g);
       if (matches) {
@@ -855,7 +1325,369 @@ function extractIgnorePatternsFromContent(content) {
       }
     }
   }
-  return patterns;
+  return patterns;
+}
+function extractAugmentCodeIgnorePatternsFromContent(content) {
+  const patterns = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("# AUGMENT_IGNORE:") || trimmed.startsWith("# augmentignore:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_IGNORE|augmentignore):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(pattern);
+      }
+    }
+    if (trimmed.startsWith("# AUGMENT_INCLUDE:") || trimmed.startsWith("# augmentinclude:")) {
+      const pattern = trimmed.replace(/^# (AUGMENT_INCLUDE|augmentinclude):\s*/, "").trim();
+      if (pattern) {
+        patterns.push(`!${pattern}`);
+      }
+    }
+    if (trimmed.includes("large file") || trimmed.includes("binary") || trimmed.includes("media")) {
+      const regex = /['"`]([^'"`]+\.(mp4|avi|zip|tar\.gz|rar|pdf|doc|xlsx))['"`]/g;
+      let match;
+      while ((match = regex.exec(trimmed)) !== null) {
+        if (match[1]) {
+          patterns.push(match[1]);
+        }
+      }
+    }
+  }
+  return patterns;
+}
+
+// src/generators/ignore/shared-factory.ts
+function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
+  const outputs = [];
+  const content = generateIgnoreContent(rules, ignoreConfig);
+  const outputPath = baseDir || process.cwd();
+  const filepath = (0, import_node_path3.join)(outputPath, ignoreConfig.filename);
+  outputs.push({
+    tool: ignoreConfig.tool,
+    filepath,
+    content
+  });
+  return outputs;
+}
+function generateIgnoreContent(rules, config) {
+  const lines = [];
+  lines.push(...config.header);
+  lines.push("");
+  if (config.includeCommonPatterns) {
+    lines.push(...getCommonIgnorePatterns());
+  }
+  if (config.corePatterns.length > 0) {
+    lines.push(...config.corePatterns);
+    lines.push("");
+  }
+  const rulePatterns = extractIgnorePatternsFromRules(rules);
+  const customPatterns = config.customPatternProcessor ? config.customPatternProcessor(rules) : [];
+  const allPatterns = [...rulePatterns, ...customPatterns];
+  if (allPatterns.length > 0) {
+    const headerText = config.projectPatternsHeader || "# \u2500\u2500\u2500\u2500\u2500 Project-specific exclusions from rulesync rules \u2500\u2500\u2500\u2500\u2500";
+    lines.push(headerText);
+    lines.push(...allPatterns);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function getCommonIgnorePatterns() {
+  return [
+    "# \u2500\u2500\u2500\u2500\u2500 Source Control Metadata \u2500\u2500\u2500\u2500\u2500",
+    ".git/",
+    ".svn/",
+    ".hg/",
+    ".idea/",
+    "*.iml",
+    ".vscode/settings.json",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Build Artifacts \u2500\u2500\u2500\u2500\u2500",
+    "/out/",
+    "/dist/",
+    "/target/",
+    "/build/",
+    "*.class",
+    "*.jar",
+    "*.war",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Secrets & Credentials \u2500\u2500\u2500\u2500\u2500",
+    "# Environment files",
+    ".env",
+    ".env.*",
+    "!.env.example",
+    "",
+    "# Key material",
+    "*.pem",
+    "*.key",
+    "*.crt",
+    "*.p12",
+    "*.pfx",
+    "*.der",
+    "id_rsa*",
+    "id_dsa*",
+    "*.ppk",
+    "",
+    "# Cloud and service configs",
+    "aws-credentials.json",
+    "gcp-service-account*.json",
+    "azure-credentials.json",
+    "secrets/**",
+    "config/secrets/",
+    "**/secrets/",
+    "",
+    "# Database credentials",
+    "database.yml",
+    "**/database/config.*",
+    "",
+    "# API keys and tokens",
+    "**/apikeys/",
+    "**/*_token*",
+    "**/*_secret*",
+    "**/*api_key*",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Infrastructure & Deployment \u2500\u2500\u2500\u2500\u2500",
+    "# Terraform state",
+    "*.tfstate",
+    "*.tfstate.*",
+    ".terraform/",
+    "",
+    "# Kubernetes secrets",
+    "**/k8s/**/secret*.yaml",
+    "**/kubernetes/**/secret*.yaml",
+    "",
+    "# Docker secrets",
+    "docker-compose.override.yml",
+    "**/docker/secrets/",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Logs & Runtime Data \u2500\u2500\u2500\u2500\u2500",
+    "*.log",
+    "*.tmp",
+    "*.cache",
+    "logs/",
+    "/var/log/",
+    "coverage/",
+    ".nyc_output/",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Large Data Files \u2500\u2500\u2500\u2500\u2500",
+    "*.csv",
+    "*.xlsx",
+    "*.sqlite",
+    "*.db",
+    "*.dump",
+    "data/",
+    "datasets/",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Node.js Specific \u2500\u2500\u2500\u2500\u2500",
+    "node_modules/",
+    ".pnpm-store/",
+    ".yarn/",
+    ".next/",
+    ".nuxt/",
+    ".cache/",
+    ".parcel-cache/",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Python Specific \u2500\u2500\u2500\u2500\u2500",
+    "__pycache__/",
+    "*.pyc",
+    "*.pyo",
+    "*.pyd",
+    ".Python",
+    "venv/",
+    ".venv/",
+    "env/",
+    ".env/",
+    "",
+    "# \u2500\u2500\u2500\u2500\u2500 Java Specific \u2500\u2500\u2500\u2500\u2500",
+    "*.class",
+    "*.jar",
+    "*.war",
+    "target/",
+    ""
+  ];
+}
+var ignoreConfigs = {
+  junie: {
+    tool: "junie",
+    filename: ".aiignore",
+    header: [
+      "# Generated by rulesync - JetBrains Junie AI ignore file",
+      "# This file controls which files the AI can access automatically",
+      "# AI must ask before reading or editing matched files/directories"
+    ],
+    corePatterns: [
+      "# \u2500\u2500\u2500\u2500\u2500 Allow specific source files (uncomment as needed) \u2500\u2500\u2500\u2500\u2500",
+      "# !src/**/*.ts",
+      "# !src/**/*.js",
+      "# !lib/**/*.py",
+      "# !src/main/**/*.java"
+    ],
+    includeCommonPatterns: true
+  },
+  kiro: {
+    tool: "kiro",
+    filename: ".aiignore",
+    header: [
+      "# Generated by rulesync - Kiro AI-specific exclusions",
+      "# This file excludes files that can be in Git but shouldn't be read by the AI"
+    ],
+    corePatterns: [
+      "# Data files AI shouldn't process",
+      "*.csv",
+      "*.tsv",
+      "*.sqlite",
+      "*.db",
+      "",
+      "# Large binary files",
+      "*.zip",
+      "*.tar.gz",
+      "*.rar",
+      "",
+      "# Sensitive documentation",
+      "internal-docs/",
+      "confidential/",
+      "",
+      "# Test data that might confuse AI",
+      "test/fixtures/large-*.json",
+      "benchmark-results/",
+      "",
+      "# Reinforce critical exclusions from .gitignore",
+      "*.pem",
+      "*.key",
+      ".env*"
+    ],
+    includeCommonPatterns: false,
+    projectPatternsHeader: "# Project-specific exclusions from rulesync rules"
+  },
+  augmentcode: {
+    tool: "augmentcode",
+    filename: ".augmentignore",
+    header: [
+      "# Generated by rulesync - AugmentCode ignore patterns",
+      "# AugmentCode uses a two-tier approach: .gitignore first, then .augmentignore",
+      "# This file provides Augment-specific exclusions and re-inclusions"
+    ],
+    corePatterns: [
+      "# Security and Secrets (critical exclusions)",
+      "# Environment files",
+      ".env*",
+      "",
+      "# Private keys and certificates",
+      "*.pem",
+      "*.key",
+      "*.p12",
+      "*.crt",
+      "*.der",
+      "",
+      "# SSH keys",
+      "id_rsa*",
+      "id_dsa*",
+      "",
+      "# AWS credentials",
+      ".aws/",
+      "aws-exports.js",
+      "",
+      "# API keys and tokens",
+      "**/apikeys/",
+      "**/*_token*",
+      "**/*_secret*",
+      "",
+      "# Build Artifacts and Dependencies",
+      "# Build outputs",
+      "dist/",
+      "build/",
+      "out/",
+      "target/",
+      "",
+      "# Dependencies",
+      "node_modules/",
+      "venv/",
+      "*.egg-info/",
+      "",
+      "# Logs",
+      "*.log",
+      "logs/",
+      "",
+      "# Temporary files",
+      "*.tmp",
+      "*.swp",
+      "*.swo",
+      "*~",
+      "",
+      "# Large Files and Media",
+      "# Binary files",
+      "*.jar",
+      "*.png",
+      "*.jpg",
+      "*.jpeg",
+      "*.gif",
+      "*.mp4",
+      "*.avi",
+      "*.zip",
+      "*.tar.gz",
+      "*.rar",
+      "",
+      "# Database files",
+      "*.sqlite",
+      "*.db",
+      "*.mdb",
+      "",
+      "# Data files",
+      "*.csv",
+      "*.tsv",
+      "*.xlsx",
+      "",
+      "# Performance Optimization",
+      "# Exclude files that are too large for effective AI processing",
+      "**/*.{mp4,avi,mov,mkv}",
+      "**/*.{zip,tar,gz,rar}",
+      "**/*.{pdf,doc,docx}",
+      "**/logs/**/*.log",
+      "",
+      "# But include small configuration files",
+      "!**/config.{json,yaml,yml}",
+      "",
+      "# Team Collaboration",
+      "# Exclude personal IDE settings",
+      ".vscode/settings.json",
+      ".idea/workspace.xml",
+      "",
+      "# But include shared team settings",
+      "!.vscode/extensions.json",
+      "!.idea/codeStyles/",
+      "",
+      "# Exclude test fixtures with sensitive data",
+      "tests/fixtures/real-data/**",
+      "",
+      "# Re-include important documentation",
+      "!vendor/*/README.md",
+      "!third-party/*/LICENSE"
+    ],
+    includeCommonPatterns: false,
+    projectPatternsHeader: "# Project-specific patterns from rulesync rules",
+    customPatternProcessor: (rules) => {
+      const augmentPatterns = [];
+      for (const rule of rules) {
+        augmentPatterns.push(...extractAugmentCodeIgnorePatternsFromContent(rule.content));
+      }
+      return augmentPatterns;
+    }
+  }
+};
+
+// src/generators/ignore/augmentcode.ts
+async function generateAugmentCodeIgnoreFiles(rules, config, baseDir) {
+  return generateIgnoreFile(rules, config, ignoreConfigs.augmentcode, baseDir);
+}
+
+// src/generators/ignore/junie.ts
+async function generateJunieIgnoreFiles(rules, config, baseDir) {
+  return generateIgnoreFile(rules, config, ignoreConfigs.junie, baseDir);
+}
+
+// src/generators/ignore/kiro.ts
+async function generateKiroIgnoreFiles(rules, config, baseDir) {
+  return generateIgnoreFile(rules, config, ignoreConfigs.kiro, baseDir);
 }
 
 // src/generators/rules/augmentcode.ts
@@ -867,75 +1699,6 @@ var import_node_path5 = require("path");
 // src/utils/ignore.ts
 var import_node_path4 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
-
-// src/utils/file.ts
-var import_promises2 = require("fs/promises");
-var import_node_path3 = require("path");
-async function ensureDir(dirPath) {
-  try {
-    await (0, import_promises2.stat)(dirPath);
-  } catch {
-    await (0, import_promises2.mkdir)(dirPath, { recursive: true });
-  }
-}
-async function readFileContent(filepath) {
-  return (0, import_promises2.readFile)(filepath, "utf-8");
-}
-async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path3.dirname)(filepath));
-  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
-}
-async function fileExists(filepath) {
-  try {
-    await (0, import_promises2.stat)(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await (0, import_promises2.readdir)(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path3.join)(dir, file));
-  } catch {
-    return [];
-  }
-}
-async function removeDirectory(dirPath) {
-  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
-  if (dangerousPaths.includes(dirPath) || dirPath === "") {
-    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    console.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await (0, import_promises2.rm)(filepath);
-    }
-  } catch (error) {
-    console.warn(`Failed to remove file ${filepath}:`, error);
-  }
-}
-async function removeClaudeGeneratedFiles() {
-  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
-  for (const fileOrDir of filesToRemove) {
-    if (fileOrDir.endsWith("/memories")) {
-      await removeDirectory(fileOrDir);
-    } else {
-      await removeFile(fileOrDir);
-    }
-  }
-}
-
-// src/utils/ignore.ts
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
@@ -1014,16 +1777,60 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
     const ignorePath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.ignoreFileName) : generatorConfig.ignoreFileName;
-    const ignoreContent = generateIgnoreFile(ignorePatterns.patterns, generatorConfig.tool);
+    const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, generatorConfig.tool);
+    outputs.push({
+      tool: generatorConfig.tool,
+      filepath: ignorePath,
+      content: ignoreContent
+    });
+  }
+  return outputs;
+}
+async function generateComplexRules(rules, config, generatorConfig, baseDir) {
+  const outputs = [];
+  const rootRules = rules.filter((r) => r.frontmatter.root === true);
+  const detailRules = rules.filter((r) => r.frontmatter.root === false);
+  const rootRule = rootRules[0];
+  if (generatorConfig.generateDetailContent && generatorConfig.detailSubDir) {
+    for (const rule of detailRules) {
+      const content = generatorConfig.generateDetailContent(rule);
+      const filepath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.detailSubDir, `${rule.filename}.md`) : (0, import_node_path5.join)(generatorConfig.detailSubDir, `${rule.filename}.md`);
+      outputs.push({
+        tool: generatorConfig.tool,
+        filepath,
+        content
+      });
+    }
+  }
+  if (generatorConfig.generateRootContent && generatorConfig.rootFilePath) {
+    const rootContent = generatorConfig.generateRootContent(rootRule, detailRules, baseDir);
+    const rootFilepath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.rootFilePath) : generatorConfig.rootFilePath;
+    outputs.push({
+      tool: generatorConfig.tool,
+      filepath: rootFilepath,
+      content: rootContent
+    });
+  }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const ignorePath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.ignoreFileName) : generatorConfig.ignoreFileName;
+    const ignoreContent = generateIgnoreFile2(ignorePatterns.patterns, generatorConfig.tool);
     outputs.push({
       tool: generatorConfig.tool,
       filepath: ignorePath,
       content: ignoreContent
     });
+    if (generatorConfig.updateAdditionalConfig) {
+      const additionalOutputs = await generatorConfig.updateAdditionalConfig(
+        ignorePatterns.patterns,
+        baseDir
+      );
+      outputs.push(...additionalOutputs);
+    }
   }
   return outputs;
 }
-function generateIgnoreFile(patterns, tool) {
+function generateIgnoreFile2(patterns, tool) {
   const lines = [
     "# Generated by rulesync from .rulesyncignore",
     "# This file is automatically generated. Do not edit manually."
@@ -1110,19 +1917,6 @@ function generateLegacyGuidelinesFile(allRules) {
 
 // src/generators/rules/claudecode.ts
 var import_node_path7 = require("path");
-
-// src/types/claudecode.ts
-var import_mini2 = require("zod/mini");
-var ClaudeSettingsSchema = import_mini2.z.looseObject({
-  permissions: import_mini2.z._default(
-    import_mini2.z.looseObject({
-      deny: import_mini2.z._default(import_mini2.z.array(import_mini2.z.string()), [])
-    }),
-    { deny: [] }
-  )
-});
-
-// src/generators/rules/claudecode.ts
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const outputs = [];
   const rootRules = rules.filter((r) => r.frontmatter.root === true);
@@ -1327,39 +2121,18 @@ function determineCursorRuleType(frontmatter) {
 }
 
 // src/generators/rules/geminicli.ts
-var import_node_path10 = require("path");
 async function generateGeminiConfig(rules, config, baseDir) {
-  const outputs = [];
-  const rootRule = rules.find((rule) => rule.frontmatter.root === true);
-  const memoryRules = rules.filter((rule) => rule.frontmatter.root === false);
-  for (const rule of memoryRules) {
-    const content = generateGeminiMemoryMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path10.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = (0, import_node_path10.join)(outputDir, `${rule.filename}.md`);
-    outputs.push({
-      tool: "geminicli",
-      filepath,
-      content
-    });
-  }
-  const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? (0, import_node_path10.join)(baseDir, "GEMINI.md") : "GEMINI.md";
-  outputs.push({
+  const generatorConfig = {
     tool: "geminicli",
-    filepath: rootFilepath,
-    content: rootContent
-  });
-  const ignorePatterns = await loadIgnorePatterns(baseDir);
-  if (ignorePatterns.patterns.length > 0) {
-    const aiexcludePath = baseDir ? (0, import_node_path10.join)(baseDir, ".aiexclude") : ".aiexclude";
-    const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
-    outputs.push({
-      tool: "geminicli",
-      filepath: aiexcludePath,
-      content: aiexcludeContent
-    });
-  }
-  return outputs;
+    fileExtension: ".md",
+    ignoreFileName: ".aiexclude",
+    generateContent: generateGeminiMemoryMarkdown,
+    generateDetailContent: generateGeminiMemoryMarkdown,
+    generateRootContent: generateGeminiRootMarkdown,
+    rootFilePath: "GEMINI.md",
+    detailSubDir: ".gemini/memories"
+  };
+  return generateComplexRules(rules, config, generatorConfig, baseDir);
 }
 function generateGeminiMemoryMarkdown(rule) {
   return rule.content.trim();
@@ -1388,24 +2161,42 @@ function generateGeminiRootMarkdown(rootRule, memoryRules, _baseDir) {
   }
   return lines.join("\n");
 }
-function generateAiexclude(patterns) {
-  const lines = [
-    "# Generated by rulesync from .rulesyncignore",
-    "# This file is automatically generated. Do not edit manually.",
-    "",
-    ...patterns
-  ];
-  return lines.join("\n");
+
+// src/generators/rules/junie.ts
+async function generateJunieConfig(rules, config, baseDir) {
+  const generatorConfig = {
+    tool: "junie",
+    fileExtension: ".md",
+    ignoreFileName: ".aiignore",
+    generateContent: (rule) => rule.content.trim(),
+    generateRootContent: generateGuidelinesMarkdown,
+    rootFilePath: ".junie/guidelines.md"
+  };
+  return generateComplexRules(rules, config, generatorConfig, baseDir);
+}
+function generateGuidelinesMarkdown(rootRule, detailRules) {
+  const lines = [];
+  if (rootRule) {
+    lines.push(rootRule.content);
+    lines.push("");
+  }
+  if (detailRules.length > 0) {
+    for (const rule of detailRules) {
+      lines.push(rule.content);
+      lines.push("");
+    }
+  }
+  return lines.join("\n").trim();
 }
 
 // src/generators/rules/kiro.ts
-var import_node_path11 = require("path");
+var import_node_path10 = require("path");
 async function generateKiroConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateKiroMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path11.join)(baseDir, config.outputPaths.kiro) : config.outputPaths.kiro;
-    const filepath = (0, import_node_path11.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path10.join)(baseDir, config.outputPaths.kiro) : config.outputPaths.kiro;
+    const filepath = (0, import_node_path10.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "kiro",
       filepath,
@@ -1459,7 +2250,10 @@ async function generateConfigurations(rules, config, targetTools, baseDir) {
 function filterRulesForTool(rules, tool, config) {
   return rules.filter((rule) => {
     const targets = resolveTargets(rule.frontmatter.targets, config);
-    return targets.includes(tool);
+    if (!targets.includes(tool)) {
+      return false;
+    }
+    return isToolSpecificRule(rule, tool);
   });
 }
 async function generateForTool(tool, rules, config, baseDir) {
@@ -1490,6 +2284,11 @@ async function generateForTool(tool, rules, config, baseDir) {
       return generateRooConfig(rules, config, baseDir);
     case "geminicli":
       return generateGeminiConfig(rules, config, baseDir);
+    case "junie": {
+      const junieRulesOutputs = await generateJunieConfig(rules, config, baseDir);
+      const junieIgnoreOutputs = await generateJunieIgnoreFiles(rules, config, baseDir);
+      return [...junieRulesOutputs, ...junieIgnoreOutputs];
+    }
     case "kiro": {
       const kiroRulesOutputs = await generateKiroConfig(rules, config, baseDir);
       const kiroIgnoreOutputs = await generateKiroIgnoreFiles(rules, config, baseDir);
@@ -1502,83 +2301,8 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path12 = require("path");
+var import_node_path11 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
-
-// src/types/config.ts
-var import_mini3 = require("zod/mini");
-init_tool_targets();
-var ConfigSchema = import_mini3.z.object({
-  aiRulesDir: import_mini3.z.string(),
-  outputPaths: import_mini3.z.record(ToolTargetSchema, import_mini3.z.string()),
-  watchEnabled: import_mini3.z.boolean(),
-  defaultTargets: ToolTargetsSchema
-});
-
-// src/types/mcp.ts
-var import_mini4 = require("zod/mini");
-init_tool_targets();
-var McpTransportTypeSchema = import_mini4.z.enum(["stdio", "sse", "http"]);
-var McpServerBaseSchema = import_mini4.z.object({
-  command: import_mini4.z.optional(import_mini4.z.string()),
-  args: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
-  url: import_mini4.z.optional(import_mini4.z.string()),
-  httpUrl: import_mini4.z.optional(import_mini4.z.string()),
-  env: import_mini4.z.optional(import_mini4.z.record(import_mini4.z.string(), import_mini4.z.string())),
-  disabled: import_mini4.z.optional(import_mini4.z.boolean()),
-  networkTimeout: import_mini4.z.optional(import_mini4.z.number()),
-  timeout: import_mini4.z.optional(import_mini4.z.number()),
-  trust: import_mini4.z.optional(import_mini4.z.boolean()),
-  cwd: import_mini4.z.optional(import_mini4.z.string()),
-  transport: import_mini4.z.optional(McpTransportTypeSchema),
-  type: import_mini4.z.optional(import_mini4.z.enum(["sse", "streamable-http"])),
-  alwaysAllow: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
-  tools: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
-  kiroAutoApprove: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string())),
-  kiroAutoBlock: import_mini4.z.optional(import_mini4.z.array(import_mini4.z.string()))
-});
-var RulesyncMcpServerSchema = import_mini4.z.extend(McpServerBaseSchema, {
-  targets: import_mini4.z.optional(RulesyncTargetsSchema)
-});
-var McpConfigSchema = import_mini4.z.object({
-  mcpServers: import_mini4.z.record(import_mini4.z.string(), McpServerBaseSchema)
-});
-var RulesyncMcpConfigSchema = import_mini4.z.object({
-  mcpServers: import_mini4.z.record(import_mini4.z.string(), RulesyncMcpServerSchema)
-});
-
-// src/types/rules.ts
-var import_mini5 = require("zod/mini");
-init_tool_targets();
-var RuleFrontmatterSchema = import_mini5.z.object({
-  root: import_mini5.z.boolean(),
-  targets: RulesyncTargetsSchema,
-  description: import_mini5.z.string(),
-  globs: import_mini5.z.array(import_mini5.z.string()),
-  cursorRuleType: import_mini5.z.optional(import_mini5.z.enum(["always", "manual", "specificFiles", "intelligently"])),
-  tags: import_mini5.z.optional(import_mini5.z.array(import_mini5.z.string()))
-});
-var ParsedRuleSchema = import_mini5.z.object({
-  frontmatter: RuleFrontmatterSchema,
-  content: import_mini5.z.string(),
-  filename: import_mini5.z.string(),
-  filepath: import_mini5.z.string()
-});
-var GeneratedOutputSchema = import_mini5.z.object({
-  tool: ToolTargetSchema,
-  filepath: import_mini5.z.string(),
-  content: import_mini5.z.string()
-});
-var GenerateOptionsSchema = import_mini5.z.object({
-  targetTools: import_mini5.z.optional(ToolTargetsSchema),
-  outputDir: import_mini5.z.optional(import_mini5.z.string()),
-  watch: import_mini5.z.optional(import_mini5.z.boolean())
-});
-
-// src/types/index.ts
-init_tool_targets();
-
-// src/core/parser.ts
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const allRuleFiles = await findFiles(aiRulesDir, ".md");
@@ -1615,7 +2339,7 @@ async function parseRuleFile(filepath) {
   const parsed = (0, import_gray_matter.default)(content);
   try {
     const frontmatter = RuleFrontmatterSchema.parse(parsed.data);
-    const filename = (0, import_node_path12.basename)(filepath, ".md");
+    const filename = (0, import_node_path11.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -1680,7 +2404,7 @@ async function validateRule(rule) {
 }
 
 // src/core/mcp-generator.ts
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 
 // src/generators/mcp/index.ts
 init_augmentcode();
@@ -1689,14 +2413,15 @@ init_cline();
 init_copilot();
 init_cursor();
 init_geminicli();
+init_junie();
 init_kiro();
 init_roo();
 
 // src/core/mcp-parser.ts
 var fs = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 function parseMcpConfig(projectRoot) {
-  const mcpPath = path2.join(projectRoot, ".rulesync", ".mcp.json");
+  const mcpPath = path3.join(projectRoot, ".rulesync", ".mcp.json");
   if (!fs.existsSync(mcpPath)) {
     return null;
   }
@@ -1720,7 +2445,7 @@ function parseMcpConfig(projectRoot) {
 }
 
 // src/core/mcp-generator.ts
-async function generateMcpConfigs(projectRoot, baseDir) {
+async function generateMcpConfigs(projectRoot, baseDir, targetTools) {
   const results = [];
   const targetRoot = baseDir || projectRoot;
   const config = parseMcpConfig(projectRoot);
@@ -1730,55 +2455,70 @@ async function generateMcpConfigs(projectRoot, baseDir) {
   const generators = [
     {
       tool: "augmentcode-project",
-      path: path3.join(targetRoot, ".mcp.json"),
+      path: path4.join(targetRoot, ".mcp.json"),
       generate: () => generateAugmentcodeMcp(config)
     },
     {
       tool: "augmentcode-legacy-project",
-      path: path3.join(targetRoot, ".mcp.json"),
+      path: path4.join(targetRoot, ".mcp.json"),
       generate: () => generateAugmentcodeMcp(config)
     },
     {
       tool: "claude-project",
-      path: path3.join(targetRoot, ".mcp.json"),
+      path: path4.join(targetRoot, ".mcp.json"),
       generate: () => generateClaudeMcp(config)
     },
     {
       tool: "copilot-editor",
-      path: path3.join(targetRoot, ".vscode", "mcp.json"),
+      path: path4.join(targetRoot, ".vscode", "mcp.json"),
       generate: () => generateCopilotMcp(config, "editor")
     },
     {
       tool: "cursor-project",
-      path: path3.join(targetRoot, ".cursor", "mcp.json"),
+      path: path4.join(targetRoot, ".cursor", "mcp.json"),
       generate: () => generateCursorMcp(config)
     },
     {
       tool: "cline-project",
-      path: path3.join(targetRoot, ".cline", "mcp.json"),
+      path: path4.join(targetRoot, ".cline", "mcp.json"),
       generate: () => generateClineMcp(config)
     },
     {
       tool: "gemini-project",
-      path: path3.join(targetRoot, ".gemini", "settings.json"),
+      path: path4.join(targetRoot, ".gemini", "settings.json"),
       generate: () => generateGeminiCliMcp(config)
     },
+    {
+      tool: "junie-project",
+      path: path4.join(targetRoot, ".junie", "mcp-config.json"),
+      generate: () => generateJunieMcp(config)
+    },
     {
       tool: "kiro-project",
-      path: path3.join(targetRoot, ".kiro", "mcp.json"),
+      path: path4.join(targetRoot, ".kiro", "mcp.json"),
       generate: () => generateKiroMcp(config)
     },
     {
       tool: "roo-project",
-      path: path3.join(targetRoot, ".roo", "mcp.json"),
+      path: path4.join(targetRoot, ".roo", "mcp.json"),
       generate: () => generateRooMcp(config)
     }
   ];
-  for (const generator of generators) {
+  const filteredGenerators = targetTools ? generators.filter((g) => {
+    const baseTool = g.tool.split("-")[0];
+    if (!isToolTarget(baseTool)) {
+      return false;
+    }
+    if (baseTool === "augmentcode") {
+      return targetTools.includes("augmentcode") || targetTools.includes("augmentcode-legacy");
+    }
+    return targetTools.includes(baseTool);
+  }) : generators;
+  for (const generator of filteredGenerators) {
     try {
       const content = generator.generate();
       const parsed = JSON.parse(content);
-      if (generator.tool.includes("augmentcode") || generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("kiro") || generator.tool.includes("roo")) {
+      if (generator.tool.includes("augmentcode") || generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("junie") || generator.tool.includes("kiro") || generator.tool.includes("roo")) {
         if (!parsed.mcpServers || Object.keys(parsed.mcpServers).length === 0) {
           results.push({
             tool: generator.tool,
@@ -1818,15 +2558,58 @@ async function generateMcpConfigs(projectRoot, baseDir) {
 
 // src/cli/commands/generate.ts
 async function generateCommand(options = {}) {
-  const config = getDefaultConfig();
-  const baseDirs = options.baseDirs || [process.cwd()];
+  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);
+  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) {
+      console.warn("\u26A0\uFE0F  Warning: CLI tool selection differs from configuration!");
+      console.warn(`   Config targets: ${configTargets.join(", ")}`);
+      console.warn(`   CLI specified: ${cliTools.join(", ")}`);
+      if (notInConfig.length > 0) {
+        console.warn(`   Tools specified but not in config: ${notInConfig.join(", ")}`);
+      }
+      if (notInCli.length > 0) {
+        console.warn(`   Tools in config but not specified: ${notInCli.join(", ")}`);
+      }
+      console.warn("\n   The configuration file targets will be used.");
+      console.warn("   To change targets, update your rulesync config file.");
+      console.warn("");
+    }
+  }
+  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()];
+  }
+  if (config.verbose && configResult.filepath) {
+    console.log(`Loaded configuration from: ${configResult.filepath}`);
+  }
   console.log("Generating configuration files...");
   if (!await fileExists(config.aiRulesDir)) {
     console.error("\u274C .rulesync directory not found. Run 'rulesync init' first.");
     process.exit(1);
   }
   try {
-    if (options.verbose) {
+    if (config.verbose) {
       console.log(`Parsing rules from ${config.aiRulesDir}...`);
     }
     const rules = await parseRulesFromDirectory(config.aiRulesDir);
@@ -1834,18 +2617,26 @@ async function generateCommand(options = {}) {
       console.warn("\u26A0\uFE0F  No rules found in .rulesync directory");
       return;
     }
-    if (options.verbose) {
+    if (config.verbose) {
       console.log(`Found ${rules.length} rule(s)`);
       console.log(`Base directories: ${baseDirs.join(", ")}`);
     }
-    if (options.delete) {
-      if (options.verbose) {
+    if (config.delete) {
+      if (config.verbose) {
         console.log("Deleting existing output directories...");
       }
-      const targetTools = options.tools || config.defaultTargets;
+      const targetTools = config.defaultTargets;
       const deleteTasks = [];
       for (const tool of targetTools) {
         switch (tool) {
+          case "augmentcode":
+            deleteTasks.push(removeDirectory((0, import_node_path12.join)(".augment", "rules")));
+            deleteTasks.push(removeDirectory((0, import_node_path12.join)(".augment", "ignore")));
+            break;
+          case "augmentcode-legacy":
+            deleteTasks.push(removeClaudeGeneratedFiles());
+            deleteTasks.push(removeDirectory((0, import_node_path12.join)(".augment", "ignore")));
+            break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
             break;
@@ -1870,19 +2661,19 @@ async function generateCommand(options = {}) {
         }
       }
       await Promise.all(deleteTasks);
-      if (options.verbose) {
+      if (config.verbose) {
         console.log("Deleted existing output directories");
       }
     }
     let totalOutputs = 0;
     for (const baseDir of baseDirs) {
-      if (options.verbose) {
+      if (config.verbose) {
         console.log(`
 Generating configurations for base directory: ${baseDir}`);
       }
-      const outputs = await generateConfigurations(rules, config, options.tools, baseDir);
+      const outputs = await generateConfigurations(rules, config, config.defaultTargets, baseDir);
       if (outputs.length === 0) {
-        if (options.verbose) {
+        if (config.verbose) {
           console.warn(`\u26A0\uFE0F  No configurations generated for ${baseDir}`);
         }
         continue;
@@ -1897,17 +2688,18 @@ Generating configurations for base directory: ${baseDir}`);
       console.warn("\u26A0\uFE0F  No configurations generated");
       return;
     }
-    if (options.verbose) {
+    if (config.verbose) {
       console.log("\nGenerating MCP configurations...");
     }
     let totalMcpOutputs = 0;
     for (const baseDir of baseDirs) {
       const mcpResults = await generateMcpConfigs(
         process.cwd(),
-        baseDir === process.cwd() ? void 0 : baseDir
+        baseDir === process.cwd() ? void 0 : baseDir,
+        config.defaultTargets
       );
       if (mcpResults.length === 0) {
-        if (options.verbose) {
+        if (config.verbose) {
           console.log(`No MCP configuration found for ${baseDir}`);
         }
         continue;
@@ -1918,7 +2710,7 @@ Generating configurations for base directory: ${baseDir}`);
           totalMcpOutputs++;
         } else if (result.status === "error") {
           console.error(`\u274C Failed to generate ${result.tool} MCP configuration: ${result.error}`);
-        } else if (options.verbose && result.status === "skipped") {
+        } else if (config.verbose && result.status === "skipped") {
           console.log(`\u23ED\uFE0F  Skipped ${result.tool} MCP configuration (no servers configured)`);
         }
       }
@@ -1937,7 +2729,7 @@ Generating configurations for base directory: ${baseDir}`);
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_path13 = require("path");
 var gitignoreCommand = async () => {
   const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
@@ -1962,6 +2754,8 @@ var gitignoreCommand = async () => {
     "**/.kiro/steering/",
     "**/.augment/rules/",
     "**/.augment-guidelines",
+    "**/.junie/guidelines.md",
+    "**/.noai",
     "**/.mcp.json",
     "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
@@ -1971,8 +2765,8 @@ var gitignoreCommand = async () => {
     "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
-  if ((0, import_node_fs.existsSync)(gitignorePath)) {
-    gitignoreContent = (0, import_node_fs.readFileSync)(gitignorePath, "utf-8");
+  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
+    gitignoreContent = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
   }
   const linesToAdd = [];
   for (const rule of rulesFilesToIgnore) {
@@ -1989,7 +2783,7 @@ var gitignoreCommand = async () => {
 ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
-  (0, import_node_fs.writeFileSync)(gitignorePath, newContent);
+  (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
   console.log(`\u2705 Added ${linesToAdd.length} rules to .gitignore:`);
   for (const line of linesToAdd) {
     if (!line.startsWith("#")) {
@@ -1999,7 +2793,7 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path18 = require("path");
+var import_node_path19 = require("path");
 var import_gray_matter5 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/augmentcode.ts
@@ -2448,7 +3242,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 var import_node_path17 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
-var import_mini6 = require("zod/mini");
+var import_mini7 = require("zod/mini");
 var customMatterOptions = {
   engines: {
     yaml: {
@@ -2476,7 +3270,7 @@ var customMatterOptions = {
   }
 };
 function convertCursorMdcFrontmatter(cursorFrontmatter, _filename) {
-  const FrontmatterSchema = import_mini6.z.record(import_mini6.z.string(), import_mini6.z.unknown());
+  const FrontmatterSchema = import_mini7.z.record(import_mini7.z.string(), import_mini7.z.unknown());
   const parseResult = FrontmatterSchema.safeParse(cursorFrontmatter);
   if (!parseResult.success) {
     return {
@@ -2688,6 +3482,42 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
   });
 }
 
+// src/parsers/junie.ts
+var import_node_path18 = require("path");
+async function parseJunieConfiguration(baseDir = process.cwd()) {
+  const errors = [];
+  const rules = [];
+  const guidelinesPath = (0, import_node_path18.join)(baseDir, ".junie", "guidelines.md");
+  if (!await fileExists(guidelinesPath)) {
+    errors.push(".junie/guidelines.md file not found");
+    return { rules, errors };
+  }
+  try {
+    const content = await readFileContent(guidelinesPath);
+    if (content.trim()) {
+      const frontmatter = {
+        root: false,
+        targets: ["junie"],
+        description: "Junie project guidelines",
+        globs: ["**/*"]
+      };
+      rules.push({
+        frontmatter,
+        content: content.trim(),
+        filename: "junie-guidelines",
+        filepath: guidelinesPath
+      });
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to parse .junie/guidelines.md: ${errorMessage}`);
+  }
+  if (rules.length === 0) {
+    errors.push("No valid Junie configuration found");
+  }
+  return { rules, errors };
+}
+
 // src/parsers/roo.ts
 async function parseRooConfiguration(baseDir = process.cwd()) {
   return parseConfigurationFiles(baseDir, {
@@ -2774,6 +3604,12 @@ async function importConfiguration(options) {
         mcpServers = geminiResult.mcpServers;
         break;
       }
+      case "junie": {
+        const junieResult = await parseJunieConfiguration(baseDir);
+        rules = junieResult.rules;
+        errors.push(...junieResult.errors);
+        break;
+      }
       default:
         errors.push(`Unsupported tool: ${tool}`);
         return { success: false, rulesCreated: 0, errors };
@@ -2786,7 +3622,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path18.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path19.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -2798,9 +3634,9 @@ async function importConfiguration(options) {
   let rulesCreated = 0;
   for (const rule of rules) {
     try {
-      const baseFilename = `${tool}__${rule.filename}`;
+      const baseFilename = rule.filename;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path19.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -2815,7 +3651,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path18.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path19.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -2831,7 +3667,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path18.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path19.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -2859,7 +3695,7 @@ function generateRuleFileContent(rule) {
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path18.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path19.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -2870,7 +3706,7 @@ async function generateUniqueFilename(rulesDir, baseFilename) {
 async function importCommand(options = {}) {
   const tools = [];
   if (options.augmentcode) tools.push("augmentcode");
-  if (options.augmentcodeLegacy) tools.push("augmentcode-legacy");
+  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");
@@ -2879,7 +3715,7 @@ async function importCommand(options = {}) {
   if (options.geminicli) tools.push("geminicli");
   if (tools.length === 0) {
     console.error(
-      "\u274C Please specify one tool to import from (--augmentcode, --augmentcodeLegacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
+      "\u274C Please specify one tool to import from (--augmentcode, --augmentcode-legacy, --claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
     );
     process.exit(1);
   }
@@ -2926,7 +3762,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path19 = require("path");
+var import_node_path20 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2973,7 +3809,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path19.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path20.join)(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -3087,11 +3923,11 @@ async function watchCommand() {
     persistent: true
   });
   let isGenerating = false;
-  const handleChange = async (path4) => {
+  const handleChange = async (path5) => {
     if (isGenerating) return;
     isGenerating = true;
     console.log(`
-\u{1F4DD} Detected change in ${path4}`);
+\u{1F4DD} Detected change in ${path5}`);
     try {
       await generateCommand({ verbose: false });
       console.log("\u2705 Regenerated configuration files");
@@ -3101,10 +3937,10 @@ async function watchCommand() {
       isGenerating = false;
     }
   };
-  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path4) => {
+  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path5) => {
     console.log(`
-\u{1F5D1}\uFE0F  Removed ${path4}`);
-    handleChange(path4);
+\u{1F5D1}\uFE0F  Removed ${path5}`);
+    handleChange(path5);
   }).on("error", (error) => {
     console.error("\u274C Watcher error:", error);
   });
@@ -3117,28 +3953,31 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new import_commander.Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.49.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.52.0");
 program.command("init").description("Initialize rulesync in current directory").action(initCommand);
 program.command("add <filename>").description("Add a new rule file").action(addCommand);
 program.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("--augmentcodeLegacy", "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("-v, --verbose", "Verbose output").action(importCommand);
-program.command("generate").description("Generate configuration files for AI tools").option("--augmentcode", "Generate only for AugmentCode").option("--augmentcodeLegacy", "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("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--kiro", "Generate only for Kiro IDE").option("--delete", "Delete all existing files in output directories before generating").option(
+program.command("import").description("Import configurations from AI tools to rulesync format").option("--augmentcode", "Import from AugmentCode (.augment/rules/)").option("--augmentcode-legacy", "Import from AugmentCode legacy format (.augment-guidelines)").option("--claudecode", "Import from Claude Code (CLAUDE.md)").option("--cursor", "Import from Cursor (.cursorrules)").option("--copilot", "Import from GitHub Copilot (.github/copilot-instructions.md)").option("--cline", "Import from Cline (.cline/instructions.md)").option("--roo", "Import from Roo Code (.roo/instructions.md)").option("--geminicli", "Import from Gemini CLI (GEMINI.md)").option("--junie", "Import from JetBrains Junie (.junie/guidelines.md)").option("-v, --verbose", "Verbose output").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("--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("--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").action(async (options) => {
+).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.augmentcodeLegacy) tools.push("augmentcode-legacy");
+  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.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");
   const generateOptions = {
     verbose: options.verbose,
-    delete: options.delete
+    delete: options.delete,
+    config: options.config,
+    noConfig: options.noConfig
   };
   if (tools.length > 0) {
     generateOptions.tools = tools;
@@ -3151,4 +3990,5 @@ program.command("generate").description("Generate configuration files for AI too
 program.command("validate").description("Validate rulesync configuration").action(validateCommand);
 program.command("status").description("Show current status of rulesync").action(statusCommand);
 program.command("watch").description("Watch for changes and auto-generate configurations").action(watchCommand);
+program.command("config").description("Show or initialize rulesync configuration").option("--init", "Initialize a new configuration file").option("--format <format>", "Configuration file format (jsonc, ts)", "jsonc").option("--targets <tools>", "Comma-separated list of tools to generate for").option("--exclude <tools>", "Comma-separated list of tools to exclude").option("--ai-rules-dir <dir>", "Directory containing AI rule files").option("--base-dir <path>", "Base directory for generation").option("--verbose", "Enable verbose output").option("--delete", "Delete existing files before generating").action(configCommand);
 program.parse();