rulesync 0.59.0 → 0.61.0

package/dist/index.js

@@ -1,16 +1,16 @@
 #!/usr/bin/env node
-import "./chunk-S3GB3VQK.js";
+import "./chunk-U63N3YDS.js";
 import "./chunk-LXTA7DBA.js";
 import "./chunk-PCATT4UZ.js";
-import "./chunk-3YQ42A7G.js";
+import "./chunk-ICMPPX55.js";
 import "./chunk-YTU3SCQO.js";
-import "./chunk-EG7LNNMW.js";
-import "./chunk-VYO76WDU.js";
-import "./chunk-DJWXF2WO.js";
+import "./chunk-3ZLMXJTX.js";
+import "./chunk-74TYZWHJ.js";
+import "./chunk-C5LFJFPS.js";
 import "./chunk-KUGTKMNW.js";
-import "./chunk-LIV53UU5.js";
-import "./chunk-5SRMJNDW.js";
-import "./chunk-OCK47GE7.js";
+import "./chunk-DA3XULAD.js";
+import "./chunk-LRYVNLH5.js";
+import "./chunk-2KYIOT5S.js";
 import {
   ALL_TOOL_TARGETS,
   RulesyncTargetsSchema,
@@ -222,13 +222,6 @@ var RuleFrontmatterSchema = z6.object({
   windsurfOutputFormat: z6.optional(z6.enum(["single-file", "directory"])),
   tags: z6.optional(z6.array(z6.string()))
 });
-var ParsedRuleSchema = z6.object({
-  frontmatter: RuleFrontmatterSchema,
-  content: z6.string(),
-  filename: z6.string(),
-  filepath: z6.string(),
-  type: z6.optional(z6.enum(["rule", "command"]))
-});
 var GeneratedOutputSchema = z6.object({
   tool: ToolTargetSchema,
   filepath: z6.string(),
@@ -740,10 +733,10 @@ export default config;
 }
 
 // src/cli/commands/generate.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/core/command-generator.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 
 // src/generators/commands/claudecode.ts
 import { join as join3 } from "path";
@@ -812,10 +805,37 @@ var GeminiCliCommandGenerator = class {
   }
 };
 
+// src/generators/commands/roo.ts
+import { join as join5 } from "path";
+var RooCommandGenerator = class {
+  generate(command, outputDir) {
+    const filepath = this.getOutputPath(command.filename, outputDir);
+    const frontmatter = ["---"];
+    if (command.frontmatter.description) {
+      frontmatter.push(`description: ${command.frontmatter.description}`);
+    }
+    frontmatter.push("---");
+    const content = `${frontmatter.join("\n")}
+
+${command.content.trim()}
+`;
+    return {
+      tool: "roo",
+      filepath,
+      content
+    };
+  }
+  getOutputPath(filename, baseDir) {
+    const flattenedName = filename.replace(/\//g, "-");
+    return join5(baseDir, ".roo", "commands", `${flattenedName}.md`);
+  }
+};
+
 // src/generators/commands/index.ts
 var commandGenerators = {
   claudecode: new ClaudeCodeCommandGenerator(),
-  geminicli: new GeminiCliCommandGenerator()
+  geminicli: new GeminiCliCommandGenerator(),
+  roo: new RooCommandGenerator()
 };
 function getCommandGenerator(tool) {
   return commandGenerators[tool];
@@ -866,7 +886,7 @@ async function parseCommandFile(filepath) {
 
 // src/core/command-generator.ts
 async function generateCommands(projectRoot, baseDir, targets) {
-  const commandsDir = join5(projectRoot, ".rulesync", "commands");
+  const commandsDir = join6(projectRoot, ".rulesync", "commands");
   if (!await fileExists(commandsDir)) {
     return [];
   }
@@ -876,7 +896,9 @@ async function generateCommands(projectRoot, baseDir, targets) {
   }
   const outputs = [];
   const outputDir = baseDir || projectRoot;
-  const supportedTargets = targets.filter((target) => ["claudecode", "geminicli"].includes(target));
+  const supportedTargets = targets.filter(
+    (target) => ["claudecode", "geminicli", "roo"].includes(target)
+  );
   for (const target of supportedTargets) {
     const generator = getCommandGenerator(target);
     if (!generator) {
@@ -898,58 +920,81 @@ async function generateCommands(projectRoot, baseDir, targets) {
 }
 
 // src/generators/ignore/shared-factory.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 
 // src/generators/ignore/shared-helpers.ts
 function extractIgnorePatternsFromRules(rules) {
   const patterns = [];
   for (const rule of rules) {
     if (rule.frontmatter.globs && rule.frontmatter.globs.length > 0) {
-      for (const glob of rule.frontmatter.globs) {
-        if (shouldExcludeFromAI(glob)) {
-          patterns.push(`# Exclude: ${rule.frontmatter.description}`);
-          patterns.push(glob);
-        }
+      const sensitiveGlobs = rule.frontmatter.globs.filter(shouldExcludeFromAI);
+      if (sensitiveGlobs.length > 0) {
+        patterns.push(`# Exclude: ${rule.frontmatter.description}`);
+        patterns.push(...sensitiveGlobs);
       }
     }
-    const contentPatterns = extractIgnorePatternsFromContent(rule.content);
+    const contentPatterns = extractBasicIgnorePatternsFromContent(rule.content);
     patterns.push(...contentPatterns);
   }
   return patterns;
 }
 function shouldExcludeFromAI(glob) {
-  const excludePatterns = [
-    // Large generated files that slow indexing
-    "**/assets/generated/**",
-    "**/public/build/**",
-    // Test fixtures with potentially sensitive data
-    "**/tests/fixtures/**",
-    "**/test/fixtures/**",
-    "**/*.fixture.*",
-    // Build outputs that provide little value for AI context
+  const sensitivePatterns = [
+    // Security-related patterns
+    "**/secret**",
+    "**/credential**",
+    "**/token**",
+    "**/key**",
+    "**/password**",
+    "**/auth**",
+    "**/private**",
+    "**/confidential**",
+    "**/internal**",
+    "**/internal-docs/**",
+    "**/admin**",
+    // Configuration patterns that might contain secrets
+    "**/config/prod**",
+    "**/config/production**",
+    "**/config/secret**",
+    "**/config/secrets/**",
+    "**/env/**",
+    "**/.env**",
+    // Build and deployment patterns
     "**/dist/**",
     "**/build/**",
-    "**/coverage/**",
-    // Configuration that might contain sensitive data
-    "**/config/production/**",
-    "**/config/secrets/**",
-    "**/config/prod/**",
-    "**/deploy/prod/**",
-    "**/*.prod.*",
-    // Internal documentation that might be sensitive
-    "**/internal/**",
-    "**/internal-docs/**",
-    "**/proprietary/**",
-    "**/personal-notes/**",
-    "**/private/**",
-    "**/confidential/**"
+    "**/target/**",
+    "**/out/**",
+    "**/node_modules/**",
+    // Data and media patterns
+    "**/data/**",
+    "**/dataset**",
+    "**/backup**",
+    "**/logs/**",
+    "**/log/**",
+    "**/temp/**",
+    "**/tmp/**",
+    "**/cache/**",
+    // Test fixtures that might contain sensitive data
+    "**/test/fixtures/**",
+    "**/test**/fixture**",
+    "**/test**/mock**",
+    "**/test**/data/**",
+    // Database and infrastructure
+    "**/*.sqlite",
+    "**/*.db",
+    "**/*.dump",
+    // Production files
+    "**/*.prod.json",
+    "**/*.production.*"
   ];
-  return excludePatterns.some((pattern) => {
-    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
-    return regex.test(glob);
+  const lowerGlob = glob.toLowerCase();
+  return sensitivePatterns.some((pattern) => {
+    const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`, "i");
+    return regex.test(lowerGlob);
   });
 }
-function extractIgnorePatternsFromContent(content) {
+function extractBasicIgnorePatternsFromContent(content) {
   const patterns = [];
   const lines = content.split("\n");
   for (const line of lines) {
@@ -960,24 +1005,6 @@ function extractIgnorePatternsFromContent(content) {
         patterns.push(pattern);
       }
     }
-    if (trimmed.startsWith("# AUGMENT_IGNORE:") || trimmed.startsWith("# augmentignore:")) {
-      const pattern = trimmed.replace(/^# (AUGMENT_IGNORE|augmentignore):\s*/, "").trim();
-      if (pattern) {
-        patterns.push(pattern);
-      }
-    }
-    if (trimmed.startsWith("# AUGMENT_INCLUDE:") || trimmed.startsWith("# augmentinclude:")) {
-      const pattern = trimmed.replace(/^# (AUGMENT_INCLUDE|augmentinclude):\s*/, "").trim();
-      if (pattern) {
-        patterns.push(`!${pattern}`);
-      }
-    }
-    if (trimmed.includes("exclude") || trimmed.includes("ignore")) {
-      const matches = trimmed.match(/['"`]([^'"`]+\.(log|tmp|cache|temp))['"`]/g);
-      if (matches) {
-        patterns.push(...matches.map((m) => m.replace(/['"`]/g, "")));
-      }
-    }
   }
   return patterns;
 }
@@ -1016,7 +1043,7 @@ function generateIgnoreFile(rules, config, ignoreConfig, baseDir) {
   const outputs = [];
   const content = generateIgnoreContent(rules, ignoreConfig);
   const outputPath = baseDir || process.cwd();
-  const filepath = join6(outputPath, ignoreConfig.filename);
+  const filepath = join7(outputPath, ignoreConfig.filename);
   outputs.push({
     tool: ignoreConfig.tool,
     filepath,
@@ -1604,20 +1631,20 @@ function generateWindsurfIgnore(rules, config, baseDir) {
 }
 
 // src/generators/rules/augmentcode.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // src/generators/rules/shared-helpers.ts
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/utils/ignore.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import micromatch from "micromatch";
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = join7(baseDir, ".rulesyncignore");
+  const ignorePath = join8(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -1671,7 +1698,7 @@ function addOutput(outputs, tool, config, baseDir, relativePath, content) {
   const outputDir = resolveOutputDir(config, tool, baseDir);
   outputs.push({
     tool,
-    filepath: join8(outputDir, relativePath),
+    filepath: join9(outputDir, relativePath),
     content
   });
 }
@@ -1680,7 +1707,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) : join8(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
+    const filepath = generatorConfig.pathResolver ? generatorConfig.pathResolver(rule, outputDir) : join9(outputDir, `${rule.filename}${generatorConfig.fileExtension}`);
     outputs.push({
       tool: generatorConfig.tool,
       filepath,
@@ -1708,7 +1735,7 @@ async function generateComplexRules(rules, config, generatorConfig, baseDir) {
     for (const rule of detailRules) {
       const content = generatorConfig.generateDetailContent(rule);
       const filepath = resolvePath(
-        join8(generatorConfig.detailSubDir, `${rule.filename}.md`),
+        join9(generatorConfig.detailSubDir, `${rule.filename}.md`),
         baseDir
       );
       outputs.push({
@@ -1771,7 +1798,7 @@ async function generateAugmentcodeConfig(rules, config, baseDir) {
       "augmentcode",
       config,
       baseDir,
-      join9(".augment", "rules", `${rule.filename}.md`),
+      join10(".augment", "rules", `${rule.filename}.md`),
       generateRuleFile(rule)
     );
   });
@@ -1824,7 +1851,7 @@ function generateLegacyGuidelinesFile(allRules) {
 }
 
 // src/generators/rules/claudecode.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const generatorConfig = {
     tool: "claudecode",
@@ -1836,7 +1863,7 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
     generateDetailContent: generateMemoryFile,
     detailSubDir: ".claude/memories",
     updateAdditionalConfig: async (ignorePatterns, baseDir2) => {
-      const settingsPath = resolvePath(join10(".claude", "settings.json"), baseDir2);
+      const settingsPath = resolvePath(join11(".claude", "settings.json"), baseDir2);
       await updateClaudeSettings(settingsPath, ignorePatterns);
       return [];
     }
@@ -1900,7 +1927,7 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
 }
 
 // src/generators/rules/generator-registry.ts
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function determineCursorRuleType(frontmatter) {
   if (frontmatter.cursorRuleType) {
     return frontmatter.cursorRuleType;
@@ -1980,7 +2007,7 @@ var GENERATOR_REGISTRY = {
     },
     pathResolver: (rule, outputDir) => {
       const baseFilename = rule.filename.replace(/\.md$/, "");
-      return join11(outputDir, `${baseFilename}.instructions.md`);
+      return join12(outputDir, `${baseFilename}.instructions.md`);
     }
   },
   cursor: {
@@ -2020,7 +2047,7 @@ var GENERATOR_REGISTRY = {
       return lines.join("\n");
     },
     pathResolver: (rule, outputDir) => {
-      return join11(outputDir, `${rule.filename}.mdc`);
+      return join12(outputDir, `${rule.filename}.mdc`);
     }
   },
   codexcli: {
@@ -2056,10 +2083,10 @@ var GENERATOR_REGISTRY = {
     pathResolver: (rule, outputDir) => {
       const outputFormat = rule.frontmatter.windsurfOutputFormat || "directory";
       if (outputFormat === "single-file") {
-        return join11(outputDir, ".windsurf-rules");
+        return join12(outputDir, ".windsurf-rules");
       } else {
-        const rulesDir = join11(outputDir, ".windsurf", "rules");
-        return join11(rulesDir, `${rule.filename}.md`);
+        const rulesDir = join12(outputDir, ".windsurf", "rules");
+        return join12(rulesDir, `${rule.filename}.md`);
       }
     }
   },
@@ -2150,10 +2177,18 @@ async function generateFromRegistry(tool, rules, config, baseDir) {
   }
 }
 
-// src/generators/rules/cline.ts
-async function generateClineConfig(rules, config, baseDir) {
-  return generateFromRegistry("cline", rules, config, baseDir);
+// src/generators/rules/generator-factory.ts
+function createSimpleGenerator(toolName) {
+  return async function(rules, config, baseDir) {
+    return generateFromRegistry(toolName, rules, config, baseDir);
+  };
 }
+var generateCursorConfig = createSimpleGenerator("cursor");
+var generateClineConfig = createSimpleGenerator("cline");
+var generateCopilotConfig = createSimpleGenerator("copilot");
+var generateWindsurfConfig = createSimpleGenerator("windsurf");
+var generateKiroConfig = createSimpleGenerator("kiro");
+var generateRooConfig = createSimpleGenerator("roo");
 
 // src/generators/rules/codexcli.ts
 async function generateCodexConfig(rules, config, baseDir) {
@@ -2200,16 +2235,6 @@ function generateConcatenatedCodexContent(rules) {
   return sections.join("\n\n---\n\n");
 }
 
-// src/generators/rules/copilot.ts
-async function generateCopilotConfig(rules, config, baseDir) {
-  return generateFromRegistry("copilot", rules, config, baseDir);
-}
-
-// src/generators/rules/cursor.ts
-async function generateCursorConfig(rules, config, baseDir) {
-  return generateFromRegistry("cursor", rules, config, baseDir);
-}
-
 // src/generators/rules/geminicli.ts
 async function generateGeminiConfig(rules, config, baseDir) {
   const generatorConfig = {
@@ -2279,21 +2304,6 @@ function generateGuidelinesMarkdown(rootRule, detailRules) {
   return lines.join("\n").trim();
 }
 
-// src/generators/rules/kiro.ts
-async function generateKiroConfig(rules, config, baseDir) {
-  return generateFromRegistry("kiro", rules, config, baseDir);
-}
-
-// src/generators/rules/roo.ts
-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();
@@ -2538,22 +2548,22 @@ async function generateMcpConfigurations(mcpConfig, baseDir, targetTools) {
       servers,
       dir
     ),
-    claudecode: async (servers, dir) => (await import("./claudecode-CRSXMPS5.js")).generateClaudeMcpConfiguration(
+    claudecode: async (servers, dir) => (await import("./claudecode-XKHMZT7R.js")).generateClaudeMcpConfiguration(
       servers,
       dir
     ),
     copilot: async (servers, dir) => (await import("./copilot-MOR3HHJX.js")).generateCopilotMcpConfiguration(servers, dir),
-    cursor: async (servers, dir) => (await import("./cursor-EXX2Q5MB.js")).generateCursorMcpConfiguration(servers, dir),
-    cline: async (servers, dir) => (await import("./cline-O67TEUFW.js")).generateClineMcpConfiguration(servers, dir),
-    codexcli: async (servers, dir) => (await import("./codexcli-S7VDKBI2.js")).generateCodexMcpConfiguration(servers, dir),
+    cursor: async (servers, dir) => (await import("./cursor-WWHUW5AD.js")).generateCursorMcpConfiguration(servers, dir),
+    cline: async (servers, dir) => (await import("./cline-FNWPJ7K4.js")).generateClineMcpConfiguration(servers, dir),
+    codexcli: async (servers, dir) => (await import("./codexcli-FDFHY66P.js")).generateCodexMcpConfiguration(servers, dir),
     roo: async (servers, dir) => (await import("./roo-L3QTTIPO.js")).generateRooMcpConfiguration(servers, dir),
-    geminicli: async (servers, dir) => (await import("./geminicli-K3FKXDKP.js")).generateGeminiCliMcpConfiguration(
+    geminicli: async (servers, dir) => (await import("./geminicli-7TIDQ62D.js")).generateGeminiCliMcpConfiguration(
       servers,
       dir
     ),
     kiro: async (servers, dir) => (await import("./kiro-YDHXY2MA.js")).generateKiroMcpConfiguration(servers, dir),
-    junie: async (servers, dir) => (await import("./junie-4SNWC452.js")).generateJunieMcpConfiguration(servers, dir),
-    windsurf: async (servers, dir) => (await import("./windsurf-NVCRKFHF.js")).generateWindsurfMcpConfiguration(
+    junie: async (servers, dir) => (await import("./junie-VMNDWBNB.js")).generateJunieMcpConfiguration(servers, dir),
+    windsurf: async (servers, dir) => (await import("./windsurf-KOSK4MZJ.js")).generateWindsurfMcpConfiguration(
       servers,
       dir
     )
@@ -2648,12 +2658,12 @@ async function generateCommand(options = {}) {
       for (const tool of targetTools) {
         switch (tool) {
           case "augmentcode":
-            deleteTasks.push(removeDirectory(join14(".augment", "rules")));
-            deleteTasks.push(removeDirectory(join14(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join15(".augment", "rules")));
+            deleteTasks.push(removeDirectory(join15(".augment", "ignore")));
             break;
           case "augmentcode-legacy":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory(join14(".augment", "ignore")));
+            deleteTasks.push(removeDirectory(join15(".augment", "ignore")));
             break;
           case "copilot":
             deleteTasks.push(removeDirectory(config.outputPaths.copilot));
@@ -2666,14 +2676,15 @@ async function generateCommand(options = {}) {
             break;
           case "claudecode":
             deleteTasks.push(removeClaudeGeneratedFiles());
-            deleteTasks.push(removeDirectory(join14(".claude", "commands")));
+            deleteTasks.push(removeDirectory(join15(".claude", "commands")));
             break;
           case "roo":
             deleteTasks.push(removeDirectory(config.outputPaths.roo));
+            deleteTasks.push(removeDirectory(join15(".roo", "commands")));
             break;
           case "geminicli":
             deleteTasks.push(removeDirectory(config.outputPaths.geminicli));
-            deleteTasks.push(removeDirectory(join14(".gemini", "commands")));
+            deleteTasks.push(removeDirectory(join15(".gemini", "commands")));
             break;
           case "kiro":
             deleteTasks.push(removeDirectory(config.outputPaths.kiro));
@@ -2789,9 +2800,9 @@ Generating configurations for base directory: ${baseDir}`);
 
 // src/cli/commands/gitignore.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = join15(process.cwd(), ".gitignore");
+  const gitignorePath = join16(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -2857,11 +2868,11 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 import matter7 from "gray-matter";
 
 // src/parsers/augmentcode.ts
-import { basename as basename3, join as join16 } from "path";
+import { basename as basename3, join as join17 } from "path";
 import matter3 from "gray-matter";
 
 // src/utils/parser-helpers.ts
@@ -2910,7 +2921,7 @@ async function parseAugmentcodeLegacyConfiguration(baseDir = process.cwd()) {
 async function parseUnifiedAugmentcode(baseDir, config) {
   const result = createParseResult();
   if (config.rulesDir) {
-    const rulesDir = join16(baseDir, config.rulesDir);
+    const rulesDir = join17(baseDir, config.rulesDir);
     if (await fileExists(rulesDir)) {
       const rulesResult = await parseAugmentRules(rulesDir, config);
       addRules(result, rulesResult.rules);
@@ -2923,7 +2934,7 @@ async function parseUnifiedAugmentcode(baseDir, config) {
     }
   }
   if (config.legacyFilePath) {
-    const legacyPath = join16(baseDir, config.legacyFilePath);
+    const legacyPath = join17(baseDir, config.legacyFilePath);
     if (await fileExists(legacyPath)) {
       const legacyResult = await parseAugmentGuidelines(legacyPath, config);
       if (legacyResult.rule) {
@@ -2947,7 +2958,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 = join16(rulesDir, file);
+        const filePath = join17(rulesDir, file);
         try {
           const rawContent = await readFileContent(filePath);
           const parsed = matter3(rawContent);
@@ -3014,7 +3025,7 @@ async function parseAugmentGuidelines(guidelinesPath, config) {
 }
 
 // src/parsers/shared-helpers.ts
-import { basename as basename4, join as join17 } from "path";
+import { basename as basename4, join as join18 } from "path";
 import matter4 from "gray-matter";
 async function parseConfigurationFiles(baseDir = process.cwd(), config) {
   const errors = [];
@@ -3070,7 +3081,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 = join17(dirPath, file);
+              const filePath = join18(dirPath, file);
               const fileResult = await safeAsyncOperation(async () => {
                 const rawContent = await readFileContent(filePath);
                 let content;
@@ -3215,7 +3226,7 @@ async function parseMemoryFiles(memoryDir, config) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join17(memoryDir, file);
+        const filePath = join18(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
           const filename = basename4(file, ".md");
@@ -3245,7 +3256,7 @@ async function parseCommandsFiles(commandsDir, config) {
     const files = await readdir2(commandsDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = join17(commandsDir, file);
+        const filePath = join18(commandsDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
           const filename = basename4(file, ".md");
@@ -3359,7 +3370,7 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/codexcli.ts
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 
 // src/parsers/copilot.ts
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
@@ -3382,7 +3393,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-import { basename as basename5, join as join19 } from "path";
+import { basename as basename5, join as join20 } from "path";
 import matter5 from "gray-matter";
 import { DEFAULT_SCHEMA, FAILSAFE_SCHEMA, load } from "js-yaml";
 import { z as z7 } from "zod/mini";
@@ -3507,7 +3518,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = join19(baseDir, ".cursorrules");
+  const cursorFilePath = join20(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -3528,14 +3539,14 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = join19(baseDir, ".cursor", "rules");
+  const cursorRulesDir = join20(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 = join19(cursorRulesDir, file);
+          const filePath = join20(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = matter5(rawContent, customMatterOptions);
@@ -3564,7 +3575,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 = join19(baseDir, ".cursorignore");
+  const cursorIgnorePath = join20(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -3577,7 +3588,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = join19(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = join20(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -3627,11 +3638,11 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/junie.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 async function parseJunieConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const guidelinesPath = join20(baseDir, ".junie", "guidelines.md");
+  const guidelinesPath = join21(baseDir, ".junie", "guidelines.md");
   if (!await fileExists(guidelinesPath)) {
     errors.push(".junie/guidelines.md file not found");
     return { rules, errors };
@@ -3684,7 +3695,7 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
 
 // src/parsers/windsurf.ts
 import { readFile as readFile2 } from "fs/promises";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 import matter6 from "gray-matter";
 
 // src/core/importer.ts
@@ -3771,7 +3782,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = join22(baseDir, rulesDir);
+  const rulesDirPath = join23(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -3786,11 +3797,11 @@ async function importConfiguration(options) {
       const baseFilename = rule.filename;
       let targetDir = rulesDirPath;
       if (rule.type === "command") {
-        targetDir = join22(rulesDirPath, "commands");
+        targetDir = join23(rulesDirPath, "commands");
         const { mkdir: mkdir3 } = await import("fs/promises");
         await mkdir3(targetDir, { recursive: true });
       }
-      const filePath = join22(targetDir, `${baseFilename}.md`);
+      const filePath = join23(targetDir, `${baseFilename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -3805,7 +3816,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = join22(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = join23(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -3821,7 +3832,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = join22(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = join23(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -3915,7 +3926,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -3962,7 +3973,7 @@ globs: ["**/*"]
 - Follow single responsibility principle
 `
   };
-  const filepath = join23(aiRulesDir, sampleFile.filename);
+  const filepath = join24(aiRulesDir, sampleFile.filename);
   if (!await fileExists(filepath)) {
     await writeFileContent(filepath, sampleFile.content);
     console.log(`Created ${filepath}`);
@@ -4106,12 +4117,12 @@ async function watchCommand() {
 
 // src/cli/index.ts
 var program = new Command();
-program.name("rulesync").description("Unified AI rules management CLI tool").version("0.59.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.61.0");
 program.command("init").description("Initialize rulesync in current directory").action(initCommand);
 program.command("add <filename>").description("Add a new rule file").action(addCommand);
 program.command("gitignore").description("Add generated files to .gitignore").action(gitignoreCommand);
 program.command("import").description("Import configurations from AI tools to rulesync format").option("--augmentcode", "Import from AugmentCode (.augment/rules/)").option("--augmentcode-legacy", "Import from AugmentCode legacy format (.augment-guidelines)").option("--claudecode", "Import from Claude Code (CLAUDE.md)").option("--cursor", "Import from Cursor (.cursorrules)").option("--copilot", "Import from GitHub Copilot (.github/copilot-instructions.md)").option("--cline", "Import from Cline (.cline/instructions.md)").option("--roo", "Import from Roo Code (.roo/instructions.md)").option("--geminicli", "Import from Gemini CLI (GEMINI.md)").option("--junie", "Import from JetBrains Junie (.junie/guidelines.md)").option("-v, --verbose", "Verbose output").action(importCommand);
-program.command("generate").description("Generate configuration files for AI tools").option("--augmentcode", "Generate only for AugmentCode").option("--augmentcode-legacy", "Generate only for AugmentCode legacy format").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--codexcli", "Generate only for OpenAI Codex CLI").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--junie", "Generate only for JetBrains Junie").option("--kiro", "Generate only for Kiro IDE").option("--delete", "Delete all existing files in output directories before generating").option(
+program.command("generate").description("Generate configuration files for AI tools").option("--augmentcode", "Generate only for AugmentCode").option("--augmentcode-legacy", "Generate only for AugmentCode legacy format").option("--copilot", "Generate only for GitHub Copilot").option("--cursor", "Generate only for Cursor").option("--cline", "Generate only for Cline").option("--codexcli", "Generate only for OpenAI Codex CLI").option("--claudecode", "Generate only for Claude Code").option("--roo", "Generate only for Roo Code").option("--geminicli", "Generate only for Gemini CLI").option("--junie", "Generate only for JetBrains Junie").option("--kiro", "Generate only for Kiro IDE").option("--windsurf", "Generate only for Windsurf").option("--delete", "Delete all existing files in output directories before generating").option(
   "-b, --base-dir <paths>",
   "Base directories to generate files (comma-separated for multiple paths)"
 ).option("-v, --verbose", "Verbose output").option("-c, --config <path>", "Path to configuration file").option("--no-config", "Disable configuration file loading").action(async (options) => {
@@ -4127,6 +4138,7 @@ program.command("generate").description("Generate configuration files for AI too
   if (options.geminicli) tools.push("geminicli");
   if (options.junie) tools.push("junie");
   if (options.kiro) tools.push("kiro");
+  if (options.windsurf) tools.push("windsurf");
   const generateOptions = {
     verbose: options.verbose,
     delete: options.delete,