rulesync 0.51.0 → 0.53.0

package/dist/index.cjs

@@ -136,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();
   }
 });
 
@@ -1217,9 +1241,9 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path14 = require("path");
+var import_node_path12 = require("path");
 
-// src/generators/ignore/augmentcode.ts
+// src/generators/ignore/shared-factory.ts
 var import_node_path3 = require("path");
 
 // src/generators/ignore/shared-helpers.ts
@@ -1333,165 +1357,43 @@ function extractAugmentCodeIgnorePatternsFromContent(content) {
   return patterns;
 }
 
-// src/generators/ignore/augmentcode.ts
-async function generateAugmentCodeIgnoreFiles(rules, config, baseDir) {
+// src/generators/ignore/shared-factory.ts
+function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
-  const augmentignoreContent = generateAugmentignoreContent(rules);
+  const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path3.join)(outputPath, ".augmentignore");
+  const filepath = (0, import_node_path3.join)(outputPath, ignoreConfig.filename);
   outputs.push({
-    tool: "augmentcode",
+    tool: ignoreConfig.tool,
     filepath,
-    content: augmentignoreContent
+    content
   });
   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);
-  const augmentPatterns = [];
-  for (const rule of rules) {
-    augmentPatterns.push(...extractAugmentCodeIgnorePatternsFromContent(rule.content));
+function generateIgnoreContent(rules, config) {
+  const lines = [];
+  lines.push(...config.header);
+  lines.push("");
+  if (config.includeCommonPatterns) {
+    lines.push(...getCommonIgnorePatterns());
   }
-  const allPatterns = [...rulePatterns, ...augmentPatterns];
+  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) {
-    lines.push("# Project-specific patterns from rulesync rules");
+    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("");
   }
-  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");
 }
-
-// src/generators/ignore/junie.ts
-var import_node_path4 = require("path");
-async function generateJunieIgnoreFiles(rules, config, baseDir) {
-  const outputs = [];
-  const aiignoreContent = generateAiignoreContent(rules);
-  const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path4.join)(outputPath, ".aiignore");
-  outputs.push({
-    tool: "junie",
-    filepath,
-    content: aiignoreContent
-  });
-  return outputs;
-}
-function generateAiignoreContent(rules) {
-  const lines = [
-    "# 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",
-    "",
+function getCommonIgnorePatterns() {
+  return [
     "# \u2500\u2500\u2500\u2500\u2500 Source Control Metadata \u2500\u2500\u2500\u2500\u2500",
     ".git/",
     ".svn/",
@@ -1603,93 +1505,206 @@ function generateAiignoreContent(rules) {
     "target/",
     ""
   ];
-  const rulePatterns = extractIgnorePatternsFromRules(rules);
-  if (rulePatterns.length > 0) {
-    lines.push("# \u2500\u2500\u2500\u2500\u2500 Project-specific exclusions from rulesync rules \u2500\u2500\u2500\u2500\u2500");
-    lines.push(...rulePatterns);
-    lines.push("");
+}
+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;
+    }
   }
-  lines.push(
-    "# \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",
-    ""
-  );
-  return lines.join("\n");
+};
+
+// 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
-var import_node_path5 = require("path");
 async function generateKiroIgnoreFiles(rules, config, baseDir) {
-  const outputs = [];
-  const aiignoreContent = generateAiignoreContent2(rules);
-  const outputPath = baseDir || process.cwd();
-  const filepath = (0, import_node_path5.join)(outputPath, ".aiignore");
-  outputs.push({
-    tool: "kiro",
-    filepath,
-    content: aiignoreContent
-  });
-  return outputs;
-}
-function generateAiignoreContent2(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 = extractIgnorePatternsFromRules(rules);
-  if (rulePatterns.length > 0) {
-    lines.push("# Project-specific exclusions from rulesync rules");
-    lines.push(...rulePatterns);
-    lines.push("");
-  }
-  return lines.join("\n");
+  return generateIgnoreFile(rules, config, ignoreConfigs.kiro, baseDir);
 }
 
 // src/generators/rules/augmentcode.ts
-var import_node_path8 = require("path");
+var import_node_path6 = require("path");
 
 // src/generators/rules/shared-helpers.ts
-var import_node_path7 = require("path");
+var import_node_path5 = require("path");
 
 // src/utils/ignore.ts
-var import_node_path6 = require("path");
+var import_node_path4 = require("path");
 var import_micromatch = __toESM(require("micromatch"), 1);
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path6.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path4.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -1734,7 +1749,7 @@ function filterIgnoredFiles(files, ignorePatterns) {
 
 // src/generators/rules/shared-helpers.ts
 function resolveOutputDir(config, tool, baseDir) {
-  return baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths[tool]) : config.outputPaths[tool];
+  return baseDir ? (0, import_node_path5.join)(baseDir, config.outputPaths[tool]) : config.outputPaths[tool];
 }
 function createOutputsArray() {
   return [];
@@ -1743,7 +1758,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: (0, import_node_path7.join)(outputDir, relativePath),
+    filepath: (0, import_node_path5.join)(outputDir, relativePath),
     content
   });
 }
@@ -1752,7 +1767,7 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   for (const rule of rules) {
     const content = generatorConfig.generateContent(rule);
     const outputDir = resolveOutputDir(config, generatorConfig.tool, baseDir);
-    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path7.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : (0, import_node_path5.join)(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -1761,8 +1776,8 @@ async function generateRulesConfig(rules, config, generatorConfig, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const ignorePath = baseDir ? (0, import_node_path7.join)(baseDir, generatorConfig.ignoreFileName) : generatorConfig.ignoreFileName;
-    const ignoreContent = generateIgnoreFile(ignorePatterns.patterns, generatorConfig.tool);
+    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,
@@ -1779,7 +1794,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
   if (generatorConfig.generateDetailContent && generatorConfig.detailSubDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
-      const filepath = baseDir ? (0, import_node_path7.join)(baseDir, generatorConfig.detailSubDir, `${rule.filename}.md`) : (0, import_node_path7.join)(generatorConfig.detailSubDir, `${rule.filename}.md`);
+      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,
@@ -1789,7 +1804,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
   }
   if (generatorConfig.generateRootContent && generatorConfig.rootFilePath) {
     const rootContent = generatorConfig.generateRootContent(rootRule, detailRules, baseDir);
-    const rootFilepath = baseDir ? (0, import_node_path7.join)(baseDir, generatorConfig.rootFilePath) : generatorConfig.rootFilePath;
+    const rootFilepath = baseDir ? (0, import_node_path5.join)(baseDir, generatorConfig.rootFilePath) : generatorConfig.rootFilePath;
     outputs.push({
       tool: generatorConfig.tool,
       filepath: rootFilepath,
@@ -1798,8 +1813,8 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const ignorePath = baseDir ? (0, import_node_path7.join)(baseDir, generatorConfig.ignoreFileName) : generatorConfig.ignoreFileName;
-    const ignoreContent = generateIgnoreFile(ignorePatterns.patterns, generatorConfig.tool);
+    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,
@@ -1815,7 +1830,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
   }
   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."
@@ -1848,7 +1863,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      (0, import_node_path8.join)(".augment", "rules", `${rule.filename}.md`),
+      (0, import_node_path6.join)(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile(rule)
     );
   });
@@ -1901,29 +1916,29 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path9 = require("path");
+var import_node_path7 = require("path");
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const outputs = [];
   const rootRules = rules.filter((r) => r.frontmatter.root === true);
   const detailRules = rules.filter((r) => r.frontmatter.root === false);
   const claudeMdContent = generateClaudeMarkdown(rootRules, detailRules);
-  const claudeOutputDir = baseDir ? (0, import_node_path9.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
+  const claudeOutputDir = baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
   outputs.push({
     tool: "claudecode",
-    filepath: (0, import_node_path9.join)(claudeOutputDir, "CLAUDE.md"),
+    filepath: (0, import_node_path7.join)(claudeOutputDir, "CLAUDE.md"),
     content: claudeMdContent
   });
   for (const rule of detailRules) {
     const memoryContent = generateMemoryFile(rule);
     outputs.push({
       tool: "claudecode",
-      filepath: (0, import_node_path9.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
+      filepath: (0, import_node_path7.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
       content: memoryContent
     });
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const settingsPath = baseDir ? (0, import_node_path9.join)(baseDir, ".claude", "settings.json") : (0, import_node_path9.join)(".claude", "settings.json");
+    const settingsPath = baseDir ? (0, import_node_path7.join)(baseDir, ".claude", "settings.json") : (0, import_node_path7.join)(".claude", "settings.json");
     await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
   }
   return outputs;
@@ -2002,7 +2017,7 @@ async function generateClineConfig(rules, config, baseDir) {
 }
 
 // src/generators/rules/copilot.ts
-var import_node_path10 = require("path");
+var import_node_path8 = require("path");
 async function generateCopilotConfig(rules, config, baseDir) {
   return generateComplexRulesConfig(
     rules,
@@ -2014,7 +2029,7 @@ async function generateCopilotConfig(rules, config, baseDir) {
       generateContent: generateCopilotMarkdown,
       getOutputPath: (rule, outputDir) => {
         const baseFilename = rule.filename.replace(/\.md$/, "");
-        return (0, import_node_path10.join)(outputDir, `${baseFilename}.instructions.md`);
+        return (0, import_node_path8.join)(outputDir, `${baseFilename}.instructions.md`);
       }
     },
     baseDir
@@ -2035,7 +2050,7 @@ function generateCopilotMarkdown(rule) {
 }
 
 // src/generators/rules/cursor.ts
-var import_node_path11 = require("path");
+var import_node_path9 = require("path");
 async function generateCursorConfig(rules, config, baseDir) {
   return generateComplexRulesConfig(
     rules,
@@ -2046,7 +2061,7 @@ async function generateCursorConfig(rules, config, baseDir) {
       ignoreFileName: ".cursorignore",
       generateContent: generateCursorMarkdown,
       getOutputPath: (rule, outputDir) => {
-        return (0, import_node_path11.join)(outputDir, `${rule.filename}.mdc`);
+        return (0, import_node_path9.join)(outputDir, `${rule.filename}.mdc`);
       }
     },
     baseDir
@@ -2175,13 +2190,13 @@ function generateGuidelinesMarkdown(rootRule, detailRules) {
 }
 
 // src/generators/rules/kiro.ts
-var import_node_path12 = 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_path12.join)(baseDir, config.outputPaths.kiro) : config.outputPaths.kiro;
-    const filepath = (0, import_node_path12.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,
@@ -2286,7 +2301,7 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path13 = require("path");
+var import_node_path11 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
@@ -2324,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_path13.basename)(filepath, ".md");
+    const filename = (0, import_node_path11.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -2615,12 +2630,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "rules")));
-            deleteTasks.push(removeDirectory((0, import_node_path14.join)(".augment", "ignore")));
+            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_path14.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path12.join)(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -2715,9 +2730,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path15 = require("path");
+var import_node_path13 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path15.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -2778,11 +2793,11 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path21 = require("path");
+var import_node_path19 = require("path");
 var import_gray_matter5 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/augmentcode.ts
-var import_node_path16 = require("path");
+var import_node_path14 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 
 // src/utils/parser-helpers.ts
@@ -2823,7 +2838,7 @@ async function safeReadFile(operation, errorContext) {
 // src/parsers/augmentcode.ts
 async function parseAugmentcodeConfiguration(baseDir = process.cwd()) {
   const result = createParseResult();
-  const rulesDir = (0, import_node_path16.join)(baseDir, ".augment", "rules");
+  const rulesDir = (0, import_node_path14.join)(baseDir, ".augment", "rules");
   if (await fileExists(rulesDir)) {
     const rulesResult = await parseAugmentRules(rulesDir);
     addRules(result, rulesResult.rules);
@@ -2841,7 +2856,7 @@ async function parseAugmentRules(rulesDir) {
     const files = await readdir2(rulesDir);
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = (0, import_node_path16.join)(rulesDir, file);
+        const filePath = (0, import_node_path14.join)(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
           const parsed = (0, import_gray_matter2.default)(rawContent);
@@ -2850,7 +2865,7 @@ async function parseAugmentRules(rulesDir) {
           const description = frontmatterData.description || "";
           const tags = Array.isArray(frontmatterData.tags) ? frontmatterData.tags : void 0;
           const isRoot = ruleType === "always";
-          const filename = (0, import_node_path16.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = (0, import_node_path14.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: ["augmentcode"],
@@ -2879,10 +2894,10 @@ async function parseAugmentRules(rulesDir) {
 }
 
 // src/parsers/augmentcode-legacy.ts
-var import_node_path17 = require("path");
+var import_node_path15 = require("path");
 async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
   const result = createParseResult();
-  const guidelinesPath = (0, import_node_path17.join)(baseDir, ".augment-guidelines");
+  const guidelinesPath = (0, import_node_path15.join)(baseDir, ".augment-guidelines");
   if (await fileExists(guidelinesPath)) {
     const guidelinesResult = await parseAugmentGuidelines(guidelinesPath);
     if (guidelinesResult.rule) {
@@ -2925,13 +2940,13 @@ async function parseAugmentGuidelines(guidelinesPath) {
 }
 
 // src/parsers/shared-helpers.ts
-var import_node_path18 = require("path");
+var import_node_path16 = require("path");
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
   const rules = [];
   if (config.mainFile) {
-    const mainFilePath = (0, import_node_path18.join)(baseDir, config.mainFile.path);
+    const mainFilePath = (0, import_node_path16.join)(baseDir, config.mainFile.path);
     if (await fileExists(mainFilePath)) {
       try {
         const rawContent = await readFileContent(mainFilePath);
@@ -2959,7 +2974,7 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
           rules.push({
             frontmatter,
             content,
-            filename: `${config.tool}-instructions`,
+            filename: "instructions",
             filepath: mainFilePath
           });
         }
@@ -2971,14 +2986,14 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   }
   if (config.directories) {
     for (const dirConfig of config.directories) {
-      const dirPath = (0, import_node_path18.join)(baseDir, dirConfig.directory);
+      const dirPath = (0, import_node_path16.join)(baseDir, dirConfig.directory);
       if (await fileExists(dirPath)) {
         try {
           const { readdir: readdir2 } = await import("fs/promises");
           const files = await readdir2(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = (0, import_node_path18.join)(dirPath, file);
+              const filePath = (0, import_node_path16.join)(dirPath, file);
               try {
                 const rawContent = await readFileContent(filePath);
                 let content;
@@ -2999,7 +3014,7 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
                   rules.push({
                     frontmatter,
                     content,
-                    filename: `${config.tool}-${filename}`,
+                    filename,
                     filepath: filePath
                   });
                 }
@@ -3026,7 +3041,7 @@ async function parseMemoryBasedConfiguration(baseDir = process.cwd(), config) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const mainFilePath = (0, import_node_path18.join)(baseDir, config.mainFileName);
+  const mainFilePath = (0, import_node_path16.join)(baseDir, config.mainFileName);
   if (!await fileExists(mainFilePath)) {
     errors.push(`${config.mainFileName} file not found`);
     return { rules, errors };
@@ -3037,12 +3052,12 @@ async function parseMemoryBasedConfiguration(baseDir = process.cwd(), config) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path18.join)(baseDir, config.memoryDirPath);
+    const memoryDir = (0, import_node_path16.join)(baseDir, config.memoryDirPath);
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseMemoryFiles(memoryDir, config);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path18.join)(baseDir, config.settingsPath);
+    const settingsPath = (0, import_node_path16.join)(baseDir, config.settingsPath);
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseSettingsFile(settingsPath, config.tool);
       if (settingsResult.ignorePatterns) {
@@ -3054,7 +3069,7 @@ async function parseMemoryBasedConfiguration(baseDir = process.cwd(), config) {
       errors.push(...settingsResult.errors);
     }
     if (config.additionalIgnoreFile) {
-      const additionalIgnorePath = (0, import_node_path18.join)(baseDir, config.additionalIgnoreFile.path);
+      const additionalIgnorePath = (0, import_node_path16.join)(baseDir, config.additionalIgnoreFile.path);
       if (await fileExists(additionalIgnorePath)) {
         const additionalPatterns = await config.additionalIgnoreFile.parser(additionalIgnorePath);
         if (additionalPatterns.length > 0) {
@@ -3097,7 +3112,7 @@ function parseMainFile(content, filepath, config) {
   return {
     frontmatter,
     content: mainContent,
-    filename: `${config.filenamePrefix}-main`,
+    filename: "main",
     filepath
   };
 }
@@ -3108,10 +3123,10 @@ async function parseMemoryFiles(memoryDir, config) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path18.join)(memoryDir, file);
+        const filePath = (0, import_node_path16.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path18.basename)(file, ".md");
+          const filename = (0, import_node_path16.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -3121,7 +3136,7 @@ async function parseMemoryFiles(memoryDir, config) {
           rules.push({
             frontmatter,
             content: content.trim(),
-            filename: `${config.filenamePrefix}-memory-${filename}`,
+            filename,
             filepath: filePath
           });
         }
@@ -3224,7 +3239,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path19 = require("path");
+var import_node_path17 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
 var import_mini7 = require("zod/mini");
@@ -3349,7 +3364,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path19.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path17.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -3370,20 +3385,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path19.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path17.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path19.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path17.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = (0, import_gray_matter4.default)(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path19.basename)(file, ".mdc");
+              const filename = (0, import_node_path17.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -3406,7 +3421,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  const cursorIgnorePath = (0, import_node_path19.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path17.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -3419,7 +3434,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path19.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path17.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -3468,11 +3483,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-var import_node_path20 = require("path");
+var import_node_path18 = require("path");
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = (0, import_node_path20.join)(baseDir, ".junie", "guidelines.md");
+  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 };
@@ -3607,7 +3622,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path21.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path19.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -3619,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_path21.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path19.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -3636,7 +3651,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path21.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path19.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -3652,7 +3667,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path21.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path19.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -3680,7 +3695,7 @@ function generateRuleFileContent(rule) {
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path21.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path19.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -3747,7 +3762,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path22 = require("path");
+var import_node_path20 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -3794,7 +3809,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path22.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}`);
@@ -3938,7 +3953,7 @@ 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.51.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.53.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);