rulesync 0.42.0 → 0.43.0

package/dist/index.cjs

@@ -26,44 +26,23 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/schemas/mcp.ts
-var import_zod, ToolTargetSchema, WildcardTargetSchema, SpecificTargetsSchema, RulesyncTargetsSchema, McpTransportTypeSchema, McpServerBaseSchema, RulesyncMcpServerSchema;
-var init_mcp = __esm({
-  "src/schemas/mcp.ts"() {
+// src/types/tool-targets.ts
+var import_v42, ToolTargetSchema, ToolTargetsSchema, WildcardTargetSchema, RulesyncTargetsSchema;
+var init_tool_targets = __esm({
+  "src/types/tool-targets.ts"() {
     "use strict";
-    import_zod = require("zod");
-    ToolTargetSchema = import_zod.z.enum([
+    import_v42 = require("zod/v4");
+    ToolTargetSchema = import_v42.z.enum([
       "copilot",
       "cursor",
       "cline",
       "claudecode",
-      "claude",
       "roo",
       "geminicli"
     ]);
-    WildcardTargetSchema = import_zod.z.tuple([import_zod.z.literal("*")]);
-    SpecificTargetsSchema = import_zod.z.array(ToolTargetSchema);
-    RulesyncTargetsSchema = import_zod.z.union([SpecificTargetsSchema, WildcardTargetSchema]);
-    McpTransportTypeSchema = import_zod.z.enum(["stdio", "sse", "http"]);
-    McpServerBaseSchema = import_zod.z.object({
-      command: import_zod.z.string().optional(),
-      args: import_zod.z.array(import_zod.z.string()).optional(),
-      url: import_zod.z.string().optional(),
-      httpUrl: import_zod.z.string().optional(),
-      env: import_zod.z.record(import_zod.z.string()).optional(),
-      disabled: import_zod.z.boolean().optional(),
-      networkTimeout: import_zod.z.number().optional(),
-      timeout: import_zod.z.number().optional(),
-      trust: import_zod.z.boolean().optional(),
-      cwd: import_zod.z.string().optional(),
-      transport: McpTransportTypeSchema.optional(),
-      type: import_zod.z.enum(["sse", "streamable-http"]).optional(),
-      alwaysAllow: import_zod.z.array(import_zod.z.string()).optional(),
-      tools: import_zod.z.array(import_zod.z.string()).optional()
-    });
-    RulesyncMcpServerSchema = McpServerBaseSchema.extend({
-      targets: RulesyncTargetsSchema.optional()
-    });
+    ToolTargetsSchema = import_v42.z.array(ToolTargetSchema);
+    WildcardTargetSchema = import_v42.z.tuple([import_v42.z.literal("*")]);
+    RulesyncTargetsSchema = import_v42.z.union([ToolTargetsSchema, WildcardTargetSchema]);
   }
 });
 
@@ -87,17 +66,17 @@ function shouldIncludeServer(server, targetTool) {
 var init_mcp_helpers = __esm({
   "src/utils/mcp-helpers.ts"() {
     "use strict";
-    init_mcp();
+    init_tool_targets();
   }
 });
 
-// src/generators/mcp/claude.ts
+// src/generators/mcp/claudecode.ts
 function generateClaudeMcp(config) {
   const claudeSettings = {
     mcpServers: {}
   };
   const shouldInclude = (server) => {
-    return shouldIncludeServer(server, "claude");
+    return shouldIncludeServer(server, "claudecode");
   };
   for (const [serverName, server] of Object.entries(config.mcpServers)) {
     if (!shouldInclude(server)) continue;
@@ -123,8 +102,8 @@ function generateClaudeMcp(config) {
   }
   return JSON.stringify(claudeSettings, null, 2);
 }
-var init_claude = __esm({
-  "src/generators/mcp/claude.ts"() {
+var init_claudecode = __esm({
+  "src/generators/mcp/claudecode.ts"() {
     "use strict";
     init_mcp_helpers();
   }
@@ -370,7 +349,7 @@ var import_commander = require("commander");
 
 // src/cli/commands/add.ts
 var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"), 1);
+var path = __toESM(require("path"), 1);
 
 // src/utils/config.ts
 function getDefaultConfig() {
@@ -381,12 +360,11 @@ function getDefaultConfig() {
       cursor: ".cursor/rules",
       cline: ".clinerules",
       claudecode: ".",
-      claude: ".",
       roo: ".roo/rules",
       geminicli: ".gemini/memories"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "claude", "roo", "geminicli"]
+    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli"]
   };
 }
 function resolveTargets(targets, config) {
@@ -418,7 +396,7 @@ async function addCommand(filename) {
     const config = getDefaultConfig();
     const sanitizedFilename = sanitizeFilename(filename);
     const rulesDir = config.aiRulesDir;
-    const filePath = import_node_path.default.join(rulesDir, `${sanitizedFilename}.md`);
+    const filePath = path.join(rulesDir, `${sanitizedFilename}.md`);
     await (0, import_promises.mkdir)(rulesDir, { recursive: true });
     const template = generateRuleTemplate(sanitizedFilename);
     await (0, import_promises.writeFile)(filePath, template, "utf8");
@@ -433,15 +411,23 @@ async function addCommand(filename) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path5 = require("path");
+var import_node_path4 = require("path");
+
+// src/types/claudecode.ts
+var import_v4 = require("zod/v4");
+var ClaudeSettingsSchema = import_v4.z.looseObject({
+  permissions: import_v4.z.looseObject({
+    deny: import_v4.z.array(import_v4.z.string()).default([])
+  }).default({ deny: [] })
+});
 
 // src/utils/file.ts
 var import_promises3 = require("fs/promises");
-var import_node_path4 = require("path");
+var import_node_path3 = require("path");
 
 // src/utils/file-ops.ts
 var import_promises2 = require("fs/promises");
-var import_node_path2 = require("path");
+var import_node_path = require("path");
 async function ensureDir(dirPath) {
   try {
     await (0, import_promises2.stat)(dirPath);
@@ -453,7 +439,7 @@ async function readFileContent(filepath) {
   return (0, import_promises2.readFile)(filepath, "utf-8");
 }
 async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path2.dirname)(filepath));
+  await ensureDir((0, import_node_path.dirname)(filepath));
   await (0, import_promises2.writeFile)(filepath, content, "utf-8");
 }
 async function fileExists(filepath) {
@@ -466,14 +452,14 @@ async function fileExists(filepath) {
 }
 
 // src/utils/ignore.ts
-var import_node_path3 = require("path");
+var import_node_path2 = 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_path3.join)(baseDir, ".rulesyncignore");
+  const ignorePath = (0, import_node_path2.join)(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -520,7 +506,7 @@ function filterIgnoredFiles(files, ignorePatterns) {
 async function findFiles(dir, extension = ".md", ignorePatterns) {
   try {
     const files = await (0, import_promises3.readdir)(dir);
-    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path4.join)(dir, file));
+    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path3.join)(dir, file));
     if (ignorePatterns && ignorePatterns.length > 0) {
       return filterIgnoredFiles(filtered, ignorePatterns);
     }
@@ -569,23 +555,23 @@ async function generateClaudecodeConfig(rules, config, baseDir) {
   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_path5.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
+  const claudeOutputDir = baseDir ? (0, import_node_path4.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
   outputs.push({
     tool: "claudecode",
-    filepath: (0, import_node_path5.join)(claudeOutputDir, "CLAUDE.md"),
+    filepath: (0, import_node_path4.join)(claudeOutputDir, "CLAUDE.md"),
     content: claudeMdContent
   });
   for (const rule of detailRules) {
     const memoryContent = generateMemoryFile(rule);
     outputs.push({
       tool: "claudecode",
-      filepath: (0, import_node_path5.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
+      filepath: (0, import_node_path4.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_path5.join)(baseDir, ".claude", "settings.json") : (0, import_node_path5.join)(".claude", "settings.json");
+    const settingsPath = baseDir ? (0, import_node_path4.join)(baseDir, ".claude", "settings.json") : (0, import_node_path4.join)(".claude", "settings.json");
     await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
   }
   return outputs;
@@ -617,51 +603,46 @@ function generateMemoryFile(rule) {
   return rule.content.trim();
 }
 async function updateClaudeSettings(settingsPath, ignorePatterns) {
-  let settings = {};
+  let rawSettings = {};
   if (await fileExists(settingsPath)) {
     try {
       const content = await readFileContent(settingsPath);
-      settings = JSON.parse(content);
+      rawSettings = JSON.parse(content);
     } catch {
       console.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
-      settings = {};
+      rawSettings = {};
     }
   }
-  if (typeof settings !== "object" || settings === null) {
-    settings = {};
-  }
-  const settingsObj = settings;
-  if (!settingsObj.permissions || typeof settingsObj.permissions !== "object" || settingsObj.permissions === null) {
-    settingsObj.permissions = {};
+  const parseResult = ClaudeSettingsSchema.safeParse(rawSettings);
+  const settings = parseResult.success ? parseResult.data : ClaudeSettingsSchema.parse({});
+  const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
+  if (!settings.permissions) {
+    settings.permissions = { deny: [] };
   }
-  const permissions = settingsObj.permissions;
-  if (!Array.isArray(permissions.deny)) {
-    permissions.deny = [];
+  if (!Array.isArray(settings.permissions.deny)) {
+    settings.permissions.deny = [];
   }
-  const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
-  const denyArray = permissions.deny;
-  const filteredDeny = denyArray.filter((rule) => {
-    if (typeof rule !== "string") return false;
+  const filteredDeny = settings.permissions.deny.filter((rule) => {
     if (!rule.startsWith("Read(")) return true;
     const match = rule.match(/^Read\((.*)\)$/);
     if (!match) return true;
     return !ignorePatterns.includes(match[1] ?? "");
   });
   filteredDeny.push(...readDenyRules);
-  permissions.deny = [...new Set(filteredDeny)];
-  const jsonContent = JSON.stringify(settingsObj, null, 2);
+  settings.permissions.deny = Array.from(new Set(filteredDeny));
+  const jsonContent = JSON.stringify(settings, null, 2);
   await writeFileContent(settingsPath, jsonContent);
   console.log(`\u2705 Updated Claude Code settings: ${settingsPath}`);
 }
 
 // src/generators/rules/cline.ts
-var import_node_path6 = require("path");
+var import_node_path5 = require("path");
 async function generateClineConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateClineMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path6.join)(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
-    const filepath = (0, import_node_path6.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path5.join)(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
+    const filepath = (0, import_node_path5.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "cline",
       filepath,
@@ -670,7 +651,7 @@ async function generateClineConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const clineIgnorePath = baseDir ? (0, import_node_path6.join)(baseDir, ".clineignore") : ".clineignore";
+    const clineIgnorePath = baseDir ? (0, import_node_path5.join)(baseDir, ".clineignore") : ".clineignore";
     const clineIgnoreContent = generateClineIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cline",
@@ -694,14 +675,14 @@ function generateClineIgnore(patterns) {
 }
 
 // src/generators/rules/copilot.ts
-var import_node_path7 = require("path");
+var import_node_path6 = require("path");
 async function generateCopilotConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCopilotMarkdown(rule);
     const baseFilename = rule.filename.replace(/\.md$/, "");
-    const outputDir = baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
-    const filepath = (0, import_node_path7.join)(outputDir, `${baseFilename}.instructions.md`);
+    const outputDir = baseDir ? (0, import_node_path6.join)(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
+    const filepath = (0, import_node_path6.join)(outputDir, `${baseFilename}.instructions.md`);
     outputs.push({
       tool: "copilot",
       filepath,
@@ -710,7 +691,7 @@ async function generateCopilotConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const copilotIgnorePath = baseDir ? (0, import_node_path7.join)(baseDir, ".copilotignore") : ".copilotignore";
+    const copilotIgnorePath = baseDir ? (0, import_node_path6.join)(baseDir, ".copilotignore") : ".copilotignore";
     const copilotIgnoreContent = generateCopilotIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "copilot",
@@ -746,13 +727,13 @@ function generateCopilotIgnore(patterns) {
 }
 
 // src/generators/rules/cursor.ts
-var import_node_path8 = require("path");
+var import_node_path7 = require("path");
 async function generateCursorConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCursorMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path8.join)(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
-    const filepath = (0, import_node_path8.join)(outputDir, `${rule.filename}.mdc`);
+    const outputDir = baseDir ? (0, import_node_path7.join)(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
+    const filepath = (0, import_node_path7.join)(outputDir, `${rule.filename}.mdc`);
     outputs.push({
       tool: "cursor",
       filepath,
@@ -761,7 +742,7 @@ async function generateCursorConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const cursorIgnorePath = baseDir ? (0, import_node_path8.join)(baseDir, ".cursorignore") : ".cursorignore";
+    const cursorIgnorePath = baseDir ? (0, import_node_path7.join)(baseDir, ".cursorignore") : ".cursorignore";
     const cursorIgnoreContent = generateCursorIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cursor",
@@ -834,15 +815,15 @@ function generateCursorIgnore(patterns) {
 }
 
 // src/generators/rules/geminicli.ts
-var import_node_path9 = require("path");
+var import_node_path8 = require("path");
 async function generateGeminiConfig(rules, config, baseDir) {
   const outputs = [];
   const rootRule = rules.find((rule) => rule.frontmatter.root === true);
   const memoryRules = rules.filter((rule) => rule.frontmatter.root === false);
   for (const rule of memoryRules) {
     const content = generateGeminiMemoryMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path9.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = (0, import_node_path9.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path8.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
+    const filepath = (0, import_node_path8.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "geminicli",
       filepath,
@@ -850,7 +831,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
     });
   }
   const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? (0, import_node_path9.join)(baseDir, "GEMINI.md") : "GEMINI.md";
+  const rootFilepath = baseDir ? (0, import_node_path8.join)(baseDir, "GEMINI.md") : "GEMINI.md";
   outputs.push({
     tool: "geminicli",
     filepath: rootFilepath,
@@ -858,7 +839,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
   });
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const aiexcludePath = baseDir ? (0, import_node_path9.join)(baseDir, ".aiexclude") : ".aiexclude";
+    const aiexcludePath = baseDir ? (0, import_node_path8.join)(baseDir, ".aiexclude") : ".aiexclude";
     const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
     outputs.push({
       tool: "geminicli",
@@ -906,13 +887,13 @@ function generateAiexclude(patterns) {
 }
 
 // src/generators/rules/roo.ts
-var import_node_path10 = require("path");
+var import_node_path9 = require("path");
 async function generateRooConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateRooMarkdown(rule);
-    const outputDir = baseDir ? (0, import_node_path10.join)(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
-    const filepath = (0, import_node_path10.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? (0, import_node_path9.join)(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
+    const filepath = (0, import_node_path9.join)(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "roo",
       filepath,
@@ -921,7 +902,7 @@ async function generateRooConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const rooIgnorePath = baseDir ? (0, import_node_path10.join)(baseDir, ".rooignore") : ".rooignore";
+    const rooIgnorePath = baseDir ? (0, import_node_path9.join)(baseDir, ".rooignore") : ".rooignore";
     const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "roo",
@@ -994,7 +975,7 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path11 = require("path");
+var import_node_path10 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"), 1);
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
@@ -1031,7 +1012,7 @@ async function parseRuleFile(filepath) {
   const parsed = (0, import_gray_matter.default)(content);
   validateFrontmatter(parsed.data, filepath);
   const frontmatter = parsed.data;
-  const filename = (0, import_node_path11.basename)(filepath, ".md");
+  const filename = (0, import_node_path10.basename)(filepath, ".md");
   return {
     frontmatter,
     content: parsed.content,
@@ -1160,10 +1141,10 @@ async function validateRule(rule) {
 }
 
 // src/core/mcp-generator.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var path3 = __toESM(require("path"), 1);
 
 // src/generators/mcp/index.ts
-init_claude();
+init_claudecode();
 init_cline();
 init_copilot();
 init_cursor();
@@ -1171,15 +1152,15 @@ init_geminicli();
 init_roo();
 
 // src/core/mcp-parser.ts
-var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var fs = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
 function parseMcpConfig(projectRoot) {
-  const mcpPath = import_node_path12.default.join(projectRoot, ".rulesync", ".mcp.json");
-  if (!import_node_fs.default.existsSync(mcpPath)) {
+  const mcpPath = path2.join(projectRoot, ".rulesync", ".mcp.json");
+  if (!fs.existsSync(mcpPath)) {
     return null;
   }
   try {
-    const content = import_node_fs.default.readFileSync(mcpPath, "utf-8");
+    const content = fs.readFileSync(mcpPath, "utf-8");
     const rawConfig = JSON.parse(content);
     if (rawConfig.servers && !rawConfig.mcpServers) {
       rawConfig.mcpServers = rawConfig.servers;
@@ -1210,32 +1191,32 @@ async function generateMcpConfigs(projectRoot, baseDir) {
   const generators = [
     {
       tool: "claude-project",
-      path: import_node_path13.default.join(targetRoot, ".mcp.json"),
+      path: path3.join(targetRoot, ".mcp.json"),
       generate: () => generateClaudeMcp(config)
     },
     {
       tool: "copilot-editor",
-      path: import_node_path13.default.join(targetRoot, ".vscode", "mcp.json"),
+      path: path3.join(targetRoot, ".vscode", "mcp.json"),
       generate: () => generateCopilotMcp(config, "editor")
     },
     {
       tool: "cursor-project",
-      path: import_node_path13.default.join(targetRoot, ".cursor", "mcp.json"),
+      path: path3.join(targetRoot, ".cursor", "mcp.json"),
       generate: () => generateCursorMcp(config)
     },
     {
       tool: "cline-project",
-      path: import_node_path13.default.join(targetRoot, ".cline", "mcp.json"),
+      path: path3.join(targetRoot, ".cline", "mcp.json"),
       generate: () => generateClineMcp(config)
     },
     {
       tool: "gemini-project",
-      path: import_node_path13.default.join(targetRoot, ".gemini", "settings.json"),
+      path: path3.join(targetRoot, ".gemini", "settings.json"),
       generate: () => generateGeminiCliMcp(config)
     },
     {
       tool: "roo-project",
-      path: import_node_path13.default.join(targetRoot, ".roo", "mcp.json"),
+      path: path3.join(targetRoot, ".roo", "mcp.json"),
       generate: () => generateRooMcp(config)
     }
   ];
@@ -1392,10 +1373,10 @@ Generating configurations for base directory: ${baseDir}`);
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_fs2 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs = require("fs");
+var import_node_path11 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path14.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",
@@ -1421,8 +1402,8 @@ var gitignoreCommand = async () => {
     "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
-  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
-    gitignoreContent = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
+  if ((0, import_node_fs.existsSync)(gitignorePath)) {
+    gitignoreContent = (0, import_node_fs.readFileSync)(gitignorePath, "utf-8");
   }
   const linesToAdd = [];
   for (const rule of rulesFilesToIgnore) {
@@ -1439,7 +1420,7 @@ var gitignoreCommand = async () => {
 ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
-  (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
+  (0, import_node_fs.writeFileSync)(gitignorePath, newContent);
   console.log(`\u2705 Added ${linesToAdd.length} rules to .gitignore:`);
   for (const line of linesToAdd) {
     if (!line.startsWith("#")) {
@@ -1449,17 +1430,17 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path21 = require("path");
+var import_node_path18 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"), 1);
 
 // src/parsers/claudecode.ts
-var import_node_path15 = require("path");
+var import_node_path12 = require("path");
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const claudeFilePath = (0, import_node_path15.join)(baseDir, "CLAUDE.md");
+  const claudeFilePath = (0, import_node_path12.join)(baseDir, "CLAUDE.md");
   if (!await fileExists(claudeFilePath)) {
     errors.push("CLAUDE.md file not found");
     return { rules, errors };
@@ -1470,12 +1451,12 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path15.join)(baseDir, ".claude", "memories");
+    const memoryDir = (0, import_node_path12.join)(baseDir, ".claude", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseClaudeMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path15.join)(baseDir, ".claude", "settings.json");
+    const settingsPath = (0, import_node_path12.join)(baseDir, ".claude", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseClaudeSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1532,10 +1513,10 @@ async function parseClaudeMemoryFiles(memoryDir) {
     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_path12.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_path12.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["claudecode"],
@@ -1594,11 +1575,11 @@ async function parseClaudeSettings(settingsPath) {
 }
 
 // src/parsers/cline.ts
-var import_node_path16 = require("path");
+var import_node_path13 = require("path");
 async function parseClineConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const clineFilePath = (0, import_node_path16.join)(baseDir, ".cline", "instructions.md");
+  const clineFilePath = (0, import_node_path13.join)(baseDir, ".cline", "instructions.md");
   if (await fileExists(clineFilePath)) {
     try {
       const content = await readFileContent(clineFilePath);
@@ -1621,14 +1602,14 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
     }
   }
-  const clinerulesDirPath = (0, import_node_path16.join)(baseDir, ".clinerules");
+  const clinerulesDirPath = (0, import_node_path13.join)(baseDir, ".clinerules");
   if (await fileExists(clinerulesDirPath)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(clinerulesDirPath);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          const filePath = (0, import_node_path16.join)(clinerulesDirPath, file);
+          const filePath = (0, import_node_path13.join)(clinerulesDirPath, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -1664,12 +1645,12 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/copilot.ts
-var import_node_path17 = require("path");
+var import_node_path14 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"), 1);
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const copilotFilePath = (0, import_node_path17.join)(baseDir, ".github", "copilot-instructions.md");
+  const copilotFilePath = (0, import_node_path14.join)(baseDir, ".github", "copilot-instructions.md");
   if (await fileExists(copilotFilePath)) {
     try {
       const rawContent = await readFileContent(copilotFilePath);
@@ -1694,19 +1675,19 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
     }
   }
-  const instructionsDir = (0, import_node_path17.join)(baseDir, ".github", "instructions");
+  const instructionsDir = (0, import_node_path14.join)(baseDir, ".github", "instructions");
   if (await fileExists(instructionsDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(instructionsDir);
       for (const file of files) {
         if (file.endsWith(".instructions.md")) {
-          const filePath = (0, import_node_path17.join)(instructionsDir, file);
+          const filePath = (0, import_node_path14.join)(instructionsDir, file);
           const rawContent = await readFileContent(filePath);
           const parsed = (0, import_gray_matter2.default)(rawContent);
           const content = parsed.content.trim();
           if (content) {
-            const filename = (0, import_node_path17.basename)(file, ".instructions.md");
+            const filename = (0, import_node_path14.basename)(file, ".instructions.md");
             const frontmatter = {
               root: false,
               targets: ["copilot"],
@@ -1736,7 +1717,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path18 = require("path");
+var import_node_path15 = require("path");
 var import_gray_matter3 = __toESM(require("gray-matter"), 1);
 var import_js_yaml = require("js-yaml");
 var customMatterOptions = {
@@ -1841,7 +1822,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path18.join)(baseDir, ".cursorrules");
+  const cursorFilePath = (0, import_node_path15.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -1862,20 +1843,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path18.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_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_path18.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path15.join)(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
             const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path18.basename)(file, ".mdc");
+              const filename = (0, import_node_path15.basename)(file, ".mdc");
               const frontmatter = convertCursorMdcFrontmatter(parsed.data, filename);
               rules.push({
                 frontmatter,
@@ -1898,7 +1879,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  const cursorIgnorePath = (0, import_node_path18.join)(baseDir, ".cursorignore");
+  const cursorIgnorePath = (0, import_node_path15.join)(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -1911,7 +1892,7 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
     }
   }
-  const cursorMcpPath = (0, import_node_path18.join)(baseDir, ".cursor", "mcp.json");
+  const cursorMcpPath = (0, import_node_path15.join)(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -1933,13 +1914,13 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
-var import_node_path19 = require("path");
+var import_node_path16 = require("path");
 async function parseGeminiConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const geminiFilePath = (0, import_node_path19.join)(baseDir, "GEMINI.md");
+  const geminiFilePath = (0, import_node_path16.join)(baseDir, "GEMINI.md");
   if (!await fileExists(geminiFilePath)) {
     errors.push("GEMINI.md file not found");
     return { rules, errors };
@@ -1950,12 +1931,12 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path19.join)(baseDir, ".gemini", "memories");
+    const memoryDir = (0, import_node_path16.join)(baseDir, ".gemini", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseGeminiMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path19.join)(baseDir, ".gemini", "settings.json");
+    const settingsPath = (0, import_node_path16.join)(baseDir, ".gemini", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseGeminiSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1966,7 +1947,7 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
       }
       errors.push(...settingsResult.errors);
     }
-    const aiexcludePath = (0, import_node_path19.join)(baseDir, ".aiexclude");
+    const aiexcludePath = (0, import_node_path16.join)(baseDir, ".aiexclude");
     if (await fileExists(aiexcludePath)) {
       const aiexcludePatterns = await parseAiexclude(aiexcludePath);
       if (aiexcludePatterns.length > 0) {
@@ -2019,10 +2000,10 @@ async function parseGeminiMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path19.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_path19.basename)(file, ".md");
+          const filename = (0, import_node_path16.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["geminicli"],
@@ -2071,11 +2052,11 @@ async function parseAiexclude(aiexcludePath) {
 }
 
 // src/parsers/roo.ts
-var import_node_path20 = require("path");
+var import_node_path17 = require("path");
 async function parseRooConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const rooFilePath = (0, import_node_path20.join)(baseDir, ".roo", "instructions.md");
+  const rooFilePath = (0, import_node_path17.join)(baseDir, ".roo", "instructions.md");
   if (await fileExists(rooFilePath)) {
     try {
       const content = await readFileContent(rooFilePath);
@@ -2098,14 +2079,14 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
     }
   }
-  const rooRulesDir = (0, import_node_path20.join)(baseDir, ".roo", "rules");
+  const rooRulesDir = (0, import_node_path17.join)(baseDir, ".roo", "rules");
   if (await fileExists(rooRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(rooRulesDir);
       for (const file of files) {
         if (file.endsWith(".md")) {
-          const filePath = (0, import_node_path20.join)(rooRulesDir, file);
+          const filePath = (0, import_node_path17.join)(rooRulesDir, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -2206,7 +2187,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_path18.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -2220,7 +2201,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path21.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path18.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -2235,7 +2216,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_path18.join)(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -2251,7 +2232,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_path18.join)(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -2279,7 +2260,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_path18.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -2344,7 +2325,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path22 = require("path");
+var import_node_path19 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2474,7 +2455,7 @@ globs: ["src/api/**/*.ts", "src/services/**/*.ts", "src/models/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = (0, import_node_path22.join)(aiRulesDir, file.filename);
+    const filepath = (0, import_node_path19.join)(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);
@@ -2617,7 +2598,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.42.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.43.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);