rulesync 0.55.0 → 0.57.0

package/dist/index.cjs

@@ -47,7 +47,8 @@ var init_tool_targets = __esm({
       "roo",
       "geminicli",
       "kiro",
-      "junie"
+      "junie",
+      "windsurf"
     ];
     ToolTargetSchema = import_mini.z.enum(ALL_TOOL_TARGETS);
     ToolTargetsSchema = import_mini.z.array(ToolTargetSchema);
@@ -147,11 +148,72 @@ function generateMcpConfig(config, toolConfig) {
   const finalConfig = toolConfig.configWrapper(servers);
   return JSON.stringify(finalConfig, null, 2);
 }
-var configWrappers;
+function generateMcpFromRegistry(tool, config) {
+  const generatorConfig = MCP_GENERATOR_REGISTRY[tool];
+  if (!generatorConfig) {
+    throw new Error(`No MCP generator configuration found for tool: ${tool}`);
+  }
+  return generateMcpConfig(config, generatorConfig);
+}
+var serverTransforms, configWrappers, MCP_GENERATOR_REGISTRY;
 var init_shared_factory = __esm({
   "src/generators/mcp/shared-factory.ts"() {
     "use strict";
     init_mcp_helpers();
+    serverTransforms = {
+      /**
+       * Basic server transformation (command, args, env, url handling)
+       */
+      basic: (server) => {
+        const result = {};
+        if (server.command) {
+          result.command = server.command;
+          if (server.args) result.args = server.args;
+        } else if (server.url || server.httpUrl) {
+          const url = server.httpUrl || server.url;
+          if (url) result.url = url;
+        }
+        if (server.env) {
+          result.env = server.env;
+        }
+        return result;
+      },
+      /**
+       * Extended server transformation (includes disabled, alwaysAllow, etc.)
+       */
+      extended: (server) => {
+        const result = serverTransforms.basic(server);
+        if (server.disabled !== void 0) {
+          result.disabled = server.disabled;
+        }
+        if (server.alwaysAllow) {
+          result.alwaysAllow = server.alwaysAllow;
+        }
+        if (server.networkTimeout !== void 0) {
+          result.networkTimeout = server.networkTimeout;
+        }
+        if (server.tools) {
+          result.tools = server.tools;
+        }
+        if (server.timeout !== void 0) {
+          result.timeout = server.timeout;
+        }
+        if (server.trust !== void 0) {
+          result.trust = server.trust;
+        }
+        if (server.headers) {
+          result.headers = server.headers;
+        }
+        return result;
+      },
+      /**
+       * Remove rulesync-specific properties from server config
+       */
+      cleanRulesyncProps: (server) => {
+        const { targets: _, transport: _transport, ...cleanServer } = server;
+        return { ...cleanServer };
+      }
+    };
     configWrappers = {
       /**
        * Standard mcpServers wrapper
@@ -166,37 +228,141 @@ var init_shared_factory = __esm({
         servers
       })
     };
+    MCP_GENERATOR_REGISTRY = {
+      claudecode: {
+        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.env) {
+            claudeServer.env = server.env;
+          }
+          return claudeServer;
+        },
+        configWrapper: configWrappers.mcpServers
+      },
+      cursor: {
+        target: "cursor",
+        configPaths: [".cursor/mcp.json"],
+        serverTransform: (server) => {
+          const cursorServer = {};
+          if (server.command) {
+            cursorServer.command = server.command;
+            if (server.args) cursorServer.args = server.args;
+          } else if (server.url || server.httpUrl) {
+            const url = server.httpUrl || server.url;
+            if (url) {
+              cursorServer.url = url;
+            }
+            if (server.httpUrl || server.transport === "http") {
+              cursorServer.type = "streamable-http";
+            } else if (server.transport === "sse" || server.type === "sse") {
+              cursorServer.type = "sse";
+            }
+          }
+          if (server.env) {
+            cursorServer.env = server.env;
+          }
+          if (server.cwd) {
+            cursorServer.cwd = server.cwd;
+          }
+          return cursorServer;
+        },
+        configWrapper: configWrappers.mcpServers
+      },
+      windsurf: {
+        target: "windsurf",
+        configPaths: ["mcp_config.json"],
+        serverTransform: (server) => {
+          const windsurfServer = {};
+          if (server.command) {
+            windsurfServer.command = server.command;
+            if (server.args) windsurfServer.args = server.args;
+          } else if (server.url || server.httpUrl) {
+            const url = server.httpUrl || server.url;
+            if (url) {
+              windsurfServer.serverUrl = url;
+            }
+          }
+          if (server.env) {
+            windsurfServer.env = server.env;
+          }
+          if (server.cwd) {
+            windsurfServer.cwd = server.cwd;
+          }
+          return windsurfServer;
+        },
+        configWrapper: configWrappers.mcpServers
+      },
+      junie: {
+        target: "junie",
+        configPaths: [".junie/mcp-config.json"],
+        serverTransform: (server, serverName) => {
+          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";
+          }
+          return junieServer;
+        },
+        configWrapper: configWrappers.mcpServers
+      },
+      cline: {
+        target: "cline",
+        configPaths: [".cline/mcp.json"],
+        serverTransform: serverTransforms.extended,
+        configWrapper: configWrappers.mcpServers
+      }
+    };
   }
 });
 
 // src/generators/mcp/claudecode.ts
 function generateClaudeMcp(config) {
-  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.env) {
-        claudeServer.env = server.env;
-      }
-      return claudeServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  });
+  return generateMcpFromRegistry("claudecode", config);
 }
 var init_claudecode = __esm({
   "src/generators/mcp/claudecode.ts"() {
@@ -207,33 +373,7 @@ var init_claudecode = __esm({
 
 // src/generators/mcp/cline.ts
 function generateClineMcp(config) {
-  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
-  });
+  return generateMcpFromRegistry("cline", config);
 }
 var init_cline = __esm({
   "src/generators/mcp/cline.ts"() {
@@ -370,137 +510,61 @@ var init_copilot = __esm({
 
 // src/generators/mcp/cursor.ts
 function generateCursorMcp(config) {
-  const cursorConfig = {
-    mcpServers: {}
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldIncludeServer(server, "cursor")) continue;
-    const cursorServer = {};
-    if (server.command) {
-      cursorServer.command = server.command;
-      if (server.args) cursorServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        cursorServer.url = url;
-      }
-      if (server.httpUrl || server.transport === "http") {
-        cursorServer.type = "streamable-http";
-      } else if (server.transport === "sse" || server.type === "sse") {
-        cursorServer.type = "sse";
-      }
-    }
-    if (server.env) {
-      cursorServer.env = server.env;
-    }
-    if (server.cwd) {
-      cursorServer.cwd = server.cwd;
-    }
-    cursorConfig.mcpServers[serverName] = cursorServer;
-  }
-  return JSON.stringify(cursorConfig, null, 2);
+  return generateMcpFromRegistry("cursor", config);
 }
 var init_cursor = __esm({
   "src/generators/mcp/cursor.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
 // src/generators/mcp/geminicli.ts
 function generateGeminiCliMcp(config) {
-  const geminiSettings = {
-    mcpServers: {}
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldIncludeServer(server, "geminicli")) continue;
-    const geminiServer = {};
-    if (server.command) {
-      geminiServer.command = server.command;
-      if (server.args) geminiServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      if (server.httpUrl) {
-        geminiServer.httpUrl = server.httpUrl;
-      } else if (server.url) {
-        geminiServer.url = server.url;
-      }
-    }
-    if (server.env) {
-      geminiServer.env = {};
-      for (const [key, value] of Object.entries(server.env)) {
-        if (value.startsWith("${") && value.endsWith("}")) {
-          geminiServer.env[key] = value;
-        } else {
-          geminiServer.env[key] = `\${${value}}`;
+  return generateMcpConfig(config, {
+    target: "geminicli",
+    configPaths: [".gemini/settings.json"],
+    serverTransform: (server) => {
+      const geminiServer = {};
+      if (server.command) {
+        geminiServer.command = server.command;
+        if (server.args) geminiServer.args = server.args;
+      } else if (server.url || server.httpUrl) {
+        if (server.httpUrl) {
+          geminiServer.httpUrl = server.httpUrl;
+        } else if (server.url) {
+          geminiServer.url = server.url;
         }
       }
-    }
-    if (server.timeout !== void 0) {
-      geminiServer.timeout = server.timeout;
-    }
-    if (server.trust !== void 0) {
-      geminiServer.trust = server.trust;
-    }
-    geminiSettings.mcpServers[serverName] = geminiServer;
-  }
-  return JSON.stringify(geminiSettings, null, 2);
+      if (server.env) {
+        geminiServer.env = server.env;
+      }
+      if (server.timeout !== void 0) {
+        geminiServer.timeout = server.timeout;
+      }
+      if (server.trust !== void 0) {
+        geminiServer.trust = server.trust;
+      }
+      return geminiServer;
+    },
+    configWrapper: configWrappers.mcpServers
+  });
 }
 var init_geminicli = __esm({
   "src/generators/mcp/geminicli.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
 // 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);
+  return generateMcpFromRegistry("junie", config);
 }
 var init_junie = __esm({
   "src/generators/mcp/junie.ts"() {
     "use strict";
-    init_mcp_helpers();
+    init_shared_factory();
   }
 });
 
@@ -607,6 +671,17 @@ var init_roo = __esm({
   }
 });
 
+// src/generators/mcp/windsurf.ts
+function generateWindsurfMcp(config) {
+  return generateMcpFromRegistry("windsurf", config);
+}
+var init_windsurf = __esm({
+  "src/generators/mcp/windsurf.ts"() {
+    "use strict";
+    init_shared_factory();
+  }
+});
+
 // src/cli/index.ts
 var import_commander = require("commander");
 
@@ -630,7 +705,8 @@ function getDefaultConfig() {
       roo: ".roo/rules",
       geminicli: ".gemini/memories",
       kiro: ".kiro/steering",
-      junie: "."
+      junie: ".",
+      windsurf: "."
     },
     watchEnabled: false,
     defaultTargets: ALL_TOOL_TARGETS.filter((tool) => tool !== "augmentcode-legacy")
@@ -719,7 +795,8 @@ var OutputPathsSchema = import_mini4.z.object({
   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())
+  junie: import_mini4.z.optional(import_mini4.z.string()),
+  windsurf: import_mini4.z.optional(import_mini4.z.string())
 });
 var ConfigOptionsSchema = import_mini4.z.object({
   aiRulesDir: import_mini4.z.optional(import_mini4.z.string()),
@@ -796,11 +873,13 @@ var RulesyncMcpConfigSchema = import_mini5.z.object({
 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()),
+  root: import_mini6.z.optional(import_mini6.z.boolean()),
+  targets: import_mini6.z.optional(RulesyncTargetsSchema),
+  description: import_mini6.z.optional(import_mini6.z.string()),
+  globs: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string())),
   cursorRuleType: import_mini6.z.optional(import_mini6.z.enum(["always", "manual", "specificFiles", "intelligently"])),
+  windsurfActivationMode: import_mini6.z.optional(import_mini6.z.enum(["always", "manual", "model-decision", "glob"])),
+  windsurfOutputFormat: import_mini6.z.optional(import_mini6.z.enum(["single-file", "directory"])),
   tags: import_mini6.z.optional(import_mini6.z.array(import_mini6.z.string()))
 });
 var ParsedRuleSchema = import_mini6.z.object({
@@ -1345,7 +1424,7 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-var import_node_path12 = require("path");
+var import_node_path10 = require("path");
 
 // src/generators/ignore/shared-factory.ts
 var import_node_path3 = require("path");
@@ -1905,6 +1984,131 @@ var ignoreConfigs = {
     ],
     includeCommonPatterns: false,
     projectPatternsHeader: "# \u2500\u2500\u2500\u2500\u2500 Project-specific patterns from rulesync rules \u2500\u2500\u2500\u2500\u2500"
+  },
+  windsurf: {
+    tool: "windsurf",
+    filename: ".codeiumignore",
+    header: [
+      "# Generated by rulesync - Windsurf AI Code Editor ignore file",
+      "# This file controls which files are excluded from Cascade AI analysis and context",
+      "# Uses same syntax as .gitignore patterns",
+      "# Note: Git-ignored files are automatically excluded by Windsurf"
+    ],
+    corePatterns: [
+      "# \u2500\u2500\u2500\u2500\u2500 Security & Credentials (Critical) \u2500\u2500\u2500\u2500\u2500",
+      "# Environment files",
+      ".env*",
+      "!.env.example",
+      "",
+      "# Private keys and certificates",
+      "*.pem",
+      "*.key",
+      "*.crt",
+      "*.p12",
+      "*.pfx",
+      "*.der",
+      "",
+      "# SSH keys",
+      "id_rsa*",
+      "id_dsa*",
+      "*.ppk",
+      "",
+      "# API keys and tokens",
+      "**/apikeys/",
+      "**/*_token*",
+      "**/*_secret*",
+      "**/*api_key*",
+      "",
+      "# Cloud provider credentials",
+      "aws-credentials.json",
+      "gcp-service-account*.json",
+      "azure-credentials.json",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Database & Configuration Files \u2500\u2500\u2500\u2500\u2500",
+      "# Database files",
+      "*.db",
+      "*.sqlite",
+      "*.sqlite3",
+      "",
+      "# Configuration files with secrets",
+      "config/secrets/",
+      "**/database.yml",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Build Artifacts & Dependencies \u2500\u2500\u2500\u2500\u2500",
+      "# Build outputs",
+      "dist/",
+      "build/",
+      "out/",
+      "target/",
+      "",
+      "# Dependencies (already auto-excluded but reinforced)",
+      "node_modules/",
+      ".pnpm-store/",
+      ".yarn/",
+      "vendor/",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Cache & Temporary Files \u2500\u2500\u2500\u2500\u2500",
+      "# Cache directories",
+      ".cache/",
+      ".parcel-cache/",
+      ".next/cache/",
+      "",
+      "# Temporary files",
+      "*.tmp",
+      "*.swp",
+      "*.swo",
+      "*~",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Large Data Files \u2500\u2500\u2500\u2500\u2500",
+      "# Data files",
+      "*.csv",
+      "*.xlsx",
+      "*.json",
+      "data/",
+      "datasets/",
+      "",
+      "# Media files",
+      "*.mp4",
+      "*.avi",
+      "*.mov",
+      "*.png",
+      "*.jpg",
+      "*.jpeg",
+      "*.gif",
+      "",
+      "# Archives",
+      "*.zip",
+      "*.tar.gz",
+      "*.rar",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 IDE & Editor Files \u2500\u2500\u2500\u2500\u2500",
+      "# IDE settings (personal)",
+      ".vscode/settings.json",
+      ".idea/",
+      "",
+      "# Editor temporary files",
+      "*.swp",
+      "*.swo",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Test Coverage & Logs \u2500\u2500\u2500\u2500\u2500",
+      "# Test coverage reports",
+      "coverage/",
+      ".nyc_output/",
+      "",
+      "# Logs",
+      "*.log",
+      "",
+      "# \u2500\u2500\u2500\u2500\u2500 Re-include Important Files \u2500\u2500\u2500\u2500\u2500",
+      "# Allow configuration examples",
+      "!.env.example",
+      "!config/*.example.*",
+      "",
+      "# Allow documentation",
+      "!docs/**/*.md",
+      "!README.md"
+    ],
+    includeCommonPatterns: false,
+    projectPatternsHeader: "# \u2500\u2500\u2500\u2500\u2500 Project-specific patterns from rulesync rules \u2500\u2500\u2500\u2500\u2500"
   }
 };
 
@@ -1923,6 +2127,11 @@ async function generateKiroIgnoreFiles(rules, config, baseDir) {
   return generateIgnoreFile(rules, config, ignoreConfigs.kiro, baseDir);
 }
 
+// src/generators/ignore/windsurf.ts
+function generateWindsurfIgnore(rules, config, baseDir) {
+  return generateIgnoreFile(rules, config, ignoreConfigs.windsurf, baseDir);
+}
+
 // src/generators/rules/augmentcode.ts
 var import_node_path6 = require("path");
 
@@ -2079,16 +2288,6 @@ function generateIgnoreFile2(patterns, tool) {
   lines.push(...patterns);
   return lines.join("\n");
 }
-async function generateComplexRulesConfig(rules, config, generatorConfig, baseDir) {
-  const unifiedConfig = {
-    tool: generatorConfig.tool,
-    fileExtension: generatorConfig.fileExtension,
-    ignoreFileName: generatorConfig.ignoreFileName,
-    generateContent: generatorConfig.generateContent,
-    pathResolver: generatorConfig.getOutputPath
-  };
-  return generateRulesConfig(rules, config, unifiedConfig, baseDir);
-}
 
 // src/generators/rules/augmentcode.ts
 async function generateAugmentcodeConfig(rules, config, baseDir) {
@@ -2159,7 +2358,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
     fileExtension: ".md",
     ignoreFileName: ".aiignore",
     generateContent: generateMemoryFile,
-    generateRootContent: (rootRule, detailRules) => generateClaudeMarkdown(rootRule ? [rootRule] : [], detailRules),
+    generateRootContent: generateClaudeMarkdown,
     rootFilePath: "CLAUDE.md",
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
@@ -2171,7 +2370,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
   };
   return generateComplexRules(rules, config, generatorConfig, baseDir);
 }
-function generateClaudeMarkdown(rootRules, detailRules) {
+function generateClaudeMarkdown(rootRule, detailRules) {
   const lines = [];
   if (detailRules.length > 0) {
     lines.push("Please also reference the following documents as needed:");
@@ -2185,11 +2384,9 @@ function generateClaudeMarkdown(rootRules, detailRules) {
     }
     lines.push("");
   }
-  if (rootRules.length > 0) {
-    for (const rule of rootRules) {
-      lines.push(rule.content);
-      lines.push("");
-    }
+  if (rootRule) {
+    lines.push(rootRule.content);
+    lines.push("");
   }
   return lines.join("\n");
 }
@@ -2231,6 +2428,27 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 
 // src/generators/rules/generator-registry.ts
 var import_node_path8 = require("path");
+function determineCursorRuleType(frontmatter) {
+  if (frontmatter.cursorRuleType) {
+    return frontmatter.cursorRuleType;
+  }
+  const isDescriptionEmpty = !frontmatter.description || frontmatter.description.trim() === "";
+  const isGlobsEmpty = frontmatter.globs.length === 0;
+  const isGlobsExactlyAllFiles = frontmatter.globs.length === 1 && frontmatter.globs[0] === "**/*";
+  if (isGlobsExactlyAllFiles) {
+    return "always";
+  }
+  if (isDescriptionEmpty && isGlobsEmpty) {
+    return "manual";
+  }
+  if (isDescriptionEmpty && !isGlobsEmpty) {
+    return "specificFiles";
+  }
+  if (!isDescriptionEmpty && isGlobsEmpty) {
+    return "intelligently";
+  }
+  return "intelligently";
+}
 var GENERATOR_REGISTRY = {
   // Simple generators - generate one file per rule
   cline: {
@@ -2295,9 +2513,42 @@ var GENERATOR_REGISTRY = {
   cursor: {
     type: "simple",
     tool: "cursor",
-    fileExtension: ".md",
+    fileExtension: ".mdc",
     ignoreFileName: ".cursorignore",
-    generateContent: (rule) => rule.content.trim()
+    generateContent: (rule) => {
+      const lines = [];
+      const ruleType = determineCursorRuleType(rule.frontmatter);
+      lines.push("---");
+      switch (ruleType) {
+        case "always":
+          lines.push("description:");
+          lines.push("globs:");
+          lines.push("alwaysApply: true");
+          break;
+        case "manual":
+          lines.push("description:");
+          lines.push("globs:");
+          lines.push("alwaysApply: false");
+          break;
+        case "specificFiles":
+          lines.push("description:");
+          lines.push(`globs: ${rule.frontmatter.globs.join(",")}`);
+          lines.push("alwaysApply: false");
+          break;
+        case "intelligently":
+          lines.push(`description: ${rule.frontmatter.description}`);
+          lines.push("globs:");
+          lines.push("alwaysApply: false");
+          break;
+      }
+      lines.push("---");
+      lines.push("");
+      lines.push(rule.content);
+      return lines.join("\n");
+    },
+    pathResolver: (rule, outputDir) => {
+      return (0, import_node_path8.join)(outputDir, `${rule.filename}.mdc`);
+    }
   },
   codexcli: {
     type: "simple",
@@ -2306,6 +2557,39 @@ var GENERATOR_REGISTRY = {
     ignoreFileName: ".codexignore",
     generateContent: (rule) => rule.content.trim()
   },
+  windsurf: {
+    type: "simple",
+    tool: "windsurf",
+    fileExtension: ".md",
+    ignoreFileName: ".codeiumignore",
+    generateContent: (rule) => {
+      const lines = [];
+      const activationMode = rule.frontmatter.windsurfActivationMode;
+      const globPattern = rule.frontmatter.globs?.[0];
+      if (activationMode || globPattern) {
+        lines.push("---");
+        if (activationMode) {
+          lines.push(`activation: ${activationMode}`);
+        }
+        if (globPattern && activationMode === "glob") {
+          lines.push(`pattern: "${globPattern}"`);
+        }
+        lines.push("---");
+        lines.push("");
+      }
+      lines.push(rule.content.trim());
+      return lines.join("\n");
+    },
+    pathResolver: (rule, outputDir) => {
+      const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
+      if (outputFormat === "single-file") {
+        return (0, import_node_path8.join)(outputDir, ".windsurf-rules");
+      } else {
+        const rulesDir = (0, import_node_path8.join)(outputDir, ".windsurf", "rules");
+        return (0, import_node_path8.join)(rulesDir, `${rule.filename}.md`);
+      }
+    }
+  },
   // Complex generators with root + detail pattern
   claudecode: {
     type: "complex",
@@ -2444,107 +2728,13 @@ function generateConcatenatedCodexContent(rules) {
 }
 
 // src/generators/rules/copilot.ts
-var import_node_path9 = require("path");
 async function generateCopilotConfig(rules, config, baseDir) {
-  return generateComplexRulesConfig(
-    rules,
-    config,
-    {
-      tool: "copilot",
-      fileExtension: ".instructions.md",
-      ignoreFileName: ".copilotignore",
-      generateContent: generateCopilotMarkdown,
-      getOutputPath: (rule, outputDir) => {
-        const baseFilename = rule.filename.replace(/\.md$/, "");
-        return (0, import_node_path9.join)(outputDir, `${baseFilename}.instructions.md`);
-      }
-    },
-    baseDir
-  );
-}
-function generateCopilotMarkdown(rule) {
-  const lines = [];
-  lines.push("---");
-  lines.push(`description: "${rule.frontmatter.description}"`);
-  if (rule.frontmatter.globs.length > 0) {
-    lines.push(`applyTo: "${rule.frontmatter.globs.join(", ")}"`);
-  } else {
-    lines.push('applyTo: "**"');
-  }
-  lines.push("---");
-  lines.push(rule.content);
-  return lines.join("\n");
+  return generateFromRegistry("copilot", rules, config, baseDir);
 }
 
 // src/generators/rules/cursor.ts
-var import_node_path10 = require("path");
 async function generateCursorConfig(rules, config, baseDir) {
-  return generateComplexRulesConfig(
-    rules,
-    config,
-    {
-      tool: "cursor",
-      fileExtension: ".mdc",
-      ignoreFileName: ".cursorignore",
-      generateContent: generateCursorMarkdown,
-      getOutputPath: (rule, outputDir) => {
-        return (0, import_node_path10.join)(outputDir, `${rule.filename}.mdc`);
-      }
-    },
-    baseDir
-  );
-}
-function generateCursorMarkdown(rule) {
-  const lines = [];
-  const ruleType = determineCursorRuleType(rule.frontmatter);
-  lines.push("---");
-  switch (ruleType) {
-    case "always":
-      lines.push("description:");
-      lines.push("globs:");
-      lines.push("alwaysApply: true");
-      break;
-    case "manual":
-      lines.push("description:");
-      lines.push("globs:");
-      lines.push("alwaysApply: false");
-      break;
-    case "specificFiles":
-      lines.push("description:");
-      lines.push(`globs: ${rule.frontmatter.globs.join(",")}`);
-      lines.push("alwaysApply: false");
-      break;
-    case "intelligently":
-      lines.push(`description: ${rule.frontmatter.description}`);
-      lines.push("globs:");
-      lines.push("alwaysApply: false");
-      break;
-  }
-  lines.push("---");
-  lines.push("");
-  lines.push(rule.content);
-  return lines.join("\n");
-}
-function determineCursorRuleType(frontmatter) {
-  if (frontmatter.cursorRuleType) {
-    return frontmatter.cursorRuleType;
-  }
-  const isDescriptionEmpty = !frontmatter.description || frontmatter.description.trim() === "";
-  const isGlobsEmpty = frontmatter.globs.length === 0;
-  const isGlobsExactlyAllFiles = frontmatter.globs.length === 1 && frontmatter.globs[0] === "**/*";
-  if (isGlobsExactlyAllFiles) {
-    return "always";
-  }
-  if (isDescriptionEmpty && isGlobsEmpty) {
-    return "manual";
-  }
-  if (isDescriptionEmpty && !isGlobsEmpty) {
-    return "specificFiles";
-  }
-  if (!isDescriptionEmpty && isGlobsEmpty) {
-    return "intelligently";
-  }
-  return "intelligently";
+  return generateFromRegistry("cursor", rules, config, baseDir);
 }
 
 // src/generators/rules/geminicli.ts
@@ -2626,6 +2816,11 @@ async function generateRooConfig(rules, config, baseDir) {
   return generateFromRegistry("roo", rules, config, baseDir);
 }
 
+// src/generators/rules/windsurf.ts
+async function generateWindsurfConfig(rules, config, baseDir) {
+  return generateFromRegistry("windsurf", rules, config, baseDir);
+}
+
 // src/core/generator.ts
 async function generateConfigurations(rules, config, targetTools, baseDir) {
   const outputs = createOutputsArray();
@@ -2698,6 +2893,11 @@ async function generateForTool(tool, rules, config, baseDir) {
       const kiroIgnoreOutputs = await generateKiroIgnoreFiles(rules, config, baseDir);
       return [...kiroRulesOutputs, ...kiroIgnoreOutputs];
     }
+    case "windsurf": {
+      const windsurfRulesOutputs = await generateWindsurfConfig(rules, config, baseDir);
+      const windsurfIgnoreOutputs = await generateWindsurfIgnore(rules, config, baseDir);
+      return [...windsurfRulesOutputs, ...windsurfIgnoreOutputs];
+    }
     default:
       console.warn(`Unknown tool: ${tool}`);
       return null;
@@ -2705,7 +2905,7 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path11 = require("path");
+var import_node_path9 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
@@ -2742,8 +2942,24 @@ async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
   const parsed = (0, import_gray_matter.default)(content);
   try {
-    const frontmatter = RuleFrontmatterSchema.parse(parsed.data);
-    const filename = (0, import_node_path11.basename)(filepath, ".md");
+    const validatedData = RuleFrontmatterSchema.parse(parsed.data);
+    const frontmatter = {
+      root: validatedData.root ?? false,
+      targets: validatedData.targets ?? ["*"],
+      description: validatedData.description ?? "",
+      globs: validatedData.globs ?? [],
+      ...validatedData.cursorRuleType !== void 0 && {
+        cursorRuleType: validatedData.cursorRuleType
+      },
+      ...validatedData.windsurfActivationMode !== void 0 && {
+        windsurfActivationMode: validatedData.windsurfActivationMode
+      },
+      ...validatedData.windsurfOutputFormat !== void 0 && {
+        windsurfOutputFormat: validatedData.windsurfOutputFormat
+      },
+      ...validatedData.tags !== void 0 && { tags: validatedData.tags }
+    };
+    const filename = (0, import_node_path9.basename)(filepath, ".md");
     return {
       frontmatter,
       content: parsed.content,
@@ -2821,6 +3037,7 @@ init_geminicli();
 init_junie();
 init_kiro();
 init_roo();
+init_windsurf();
 
 // src/core/mcp-parser.ts
 var fs = __toESM(require("fs"), 1);
@@ -2912,6 +3129,11 @@ async function generateMcpConfigs(projectRoot, baseDir, targetTools) {
       tool: "roo-project",
       path: path4.join(targetRoot, ".roo", "mcp.json"),
       generate: () => generateRooMcp(config)
+    },
+    {
+      tool: "windsurf-project",
+      path: path4.join(targetRoot, "mcp_config.json"),
+      generate: () => generateWindsurfMcp(config)
     }
   ];
   const filteredGenerators = targetTools ? generators.filter((g) => {
@@ -2928,7 +3150,7 @@ async function generateMcpConfigs(projectRoot, baseDir, targetTools) {
     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("codexcli") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("junie") || generator.tool.includes("kiro") || generator.tool.includes("roo")) {
+      if (generator.tool.includes("augmentcode") || generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("codexcli") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("junie") || generator.tool.includes("kiro") || generator.tool.includes("roo") || generator.tool.includes("windsurf")) {
         if (!parsed.mcpServers || Object.keys(parsed.mcpServers).length === 0) {
           results.push({
             tool: generator.tool,
@@ -3040,12 +3262,12 @@ async function generateCommand(options = {}) {
       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")));
+            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "rules")));
+            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory((0, import_node_path12.join)(".augment", "ignore")));
+            deleteTasks.push(removeDirectory((0, import_node_path10.join)(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -3068,6 +3290,9 @@ async function generateCommand(options = {}) {
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
             break;
+          case "windsurf":
+            deleteTasks.push(removeDirectory(config.outputPaths.windsurf));
+            break;
         }
       }
       await Promise.all(deleteTasks);
@@ -3140,9 +3365,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 var import_node_fs2 = require("fs");
-var import_node_path13 = require("path");
+var import_node_path11 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path11.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -3206,11 +3431,11 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path19 = require("path");
-var import_gray_matter5 = __toESM(require("gray-matter"), 1);
+var import_node_path18 = require("path");
+var import_gray_matter6 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/augmentcode.ts
-var import_node_path14 = require("path");
+var import_node_path12 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 
 // src/utils/parser-helpers.ts
@@ -3259,7 +3484,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = (0, import_node_path14.join)(baseDir, config.rulesDir);
+    const rulesDir = (0, import_node_path12.join)(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -3272,7 +3497,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = (0, import_node_path14.join)(baseDir, config.legacyFilePath);
+    const legacyPath = (0, import_node_path12.join)(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -3296,7 +3521,7 @@ async function parseAugmentRules(rulesDir, config) {
     const files = await readdir2(rulesDir);
     for (const file of files) {
       if (file.endsWith(".md") || file.endsWith(".mdc")) {
-        const filePath = (0, import_node_path14.join)(rulesDir, file);
+        const filePath = (0, import_node_path12.join)(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
           const parsed = (0, import_gray_matter2.default)(rawContent);
@@ -3305,7 +3530,7 @@ async function parseAugmentRules(rulesDir, config) {
           const description = frontmatterData.description || "";
           const tags = Array.isArray(frontmatterData.tags) ? frontmatterData.tags : void 0;
           const isRoot = ruleType === "always";
-          const filename = (0, import_node_path14.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
+          const filename = (0, import_node_path12.basename)(file, file.endsWith(".mdc") ? ".mdc" : ".md");
           const frontmatter = {
             root: isRoot,
             targets: [config.targetName],
@@ -3363,7 +3588,7 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/shared-helpers.ts
-var import_node_path15 = require("path");
+var import_node_path13 = require("path");
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
@@ -3419,7 +3644,7 @@ async function parseConfigurationFiles(baseDir = process.cwd(), config) {
           const files = await readdir2(dirPath);
           for (const file of files) {
             if (file.endsWith(dirConfig.filePattern)) {
-              const filePath = (0, import_node_path15.join)(dirPath, file);
+              const filePath = (0, import_node_path13.join)(dirPath, file);
               const fileResult = await safeAsyncOperation(async () => {
                 const rawContent = await readFileContent(filePath);
                 let content;
@@ -3557,10 +3782,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_path15.join)(memoryDir, file);
+        const filePath = (0, import_node_path13.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path15.basename)(file, ".md");
+          const filename = (0, import_node_path13.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: [config.tool],
@@ -3652,7 +3877,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-var import_node_path16 = require("path");
+var import_node_path14 = require("path");
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -3675,7 +3900,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path17 = require("path");
+var import_node_path15 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
 var import_mini7 = require("zod/mini");
@@ -3800,7 +4025,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path17.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path15.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -3821,20 +4046,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path17.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path15.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_path17.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path15.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_path17.basename)(file, ".mdc");
+              const filename = (0, import_node_path15.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -3857,7 +4082,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_path17.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path15.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -3870,7 +4095,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path17.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path15.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -3919,11 +4144,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-var import_node_path18 = require("path");
+var import_node_path16 = require("path");
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = (0, import_node_path18.join)(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = (0, import_node_path16.join)(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -3974,6 +4199,11 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
   });
 }
 
+// src/parsers/windsurf.ts
+var import_promises3 = require("fs/promises");
+var import_node_path17 = require("path");
+var import_gray_matter5 = __toESM(require("gray-matter"), 1);
+
 // src/core/importer.ts
 async function importConfiguration(options) {
   const { tool, baseDir = process.cwd(), rulesDir = ".rulesync", verbose = false } = options;
@@ -4058,7 +4288,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path19.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path18.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -4072,7 +4302,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = rule.filename;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path19.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -4087,7 +4317,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path19.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = (0, import_node_path18.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -4103,7 +4333,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path19.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = (0, import_node_path18.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -4125,13 +4355,13 @@ async function importConfiguration(options) {
   };
 }
 function generateRuleFileContent(rule) {
-  const frontmatter = import_gray_matter5.default.stringify("", rule.frontmatter);
+  const frontmatter = import_gray_matter6.default.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path19.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path18.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -4198,7 +4428,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path20 = require("path");
+var import_node_path19 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -4245,7 +4475,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = (0, import_node_path20.join)(aiRulesDir, sampleFile.filename);
+  const filepath = (0, import_node_path19.join)(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -4389,7 +4619,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.55.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.57.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);