rulesync 0.36.0 → 0.38.0

package/dist/index.js

@@ -1,338 +1,30 @@
 #!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/generators/mcp/claude.ts
-function generateClaudeMcp(config, _target) {
-  const claudeSettings = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    if (!server.rulesyncTargets || server.rulesyncTargets.length === 0) {
-      return true;
-    }
-    if (server.rulesyncTargets.length === 1 && server.rulesyncTargets[0] === "*") {
-      return true;
-    }
-    return server.rulesyncTargets.includes("claude");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const claudeServer = {};
-    if (server.command) {
-      claudeServer.command = server.command;
-      if (server.args) claudeServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        claudeServer.url = url;
-      }
-      if (server.httpUrl) {
-        claudeServer.transport = "http";
-      } else if (server.transport === "sse") {
-        claudeServer.transport = "sse";
-      }
-    }
-    if (server.env) {
-      claudeServer.env = server.env;
-    }
-    claudeSettings.mcpServers[serverName] = claudeServer;
-  }
-  return JSON.stringify(claudeSettings, null, 2);
-}
-var init_claude = __esm({
-  "src/generators/mcp/claude.ts"() {
-    "use strict";
-  }
-});
-
-// src/generators/mcp/cline.ts
-function generateClineMcp(config, _target) {
-  const clineConfig = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    const targets = server.rulesyncTargets;
-    if (!targets || targets.length === 0) return true;
-    if (targets.length === 1 && targets[0] === "*") return true;
-    return targets.includes("cline");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const clineServer = {};
-    if (server.command) {
-      clineServer.command = server.command;
-      if (server.args) clineServer.args = server.args;
-    } else if (server.url) {
-      clineServer.url = server.url;
-    }
-    if (server.env) {
-      clineServer.env = server.env;
-    }
-    if (server.disabled !== void 0) {
-      clineServer.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      clineServer.alwaysAllow = server.alwaysAllow;
-    }
-    if (server.networkTimeout !== void 0) {
-      clineServer.networkTimeout = server.networkTimeout;
-    }
-    clineConfig.mcpServers[serverName] = clineServer;
-  }
-  return JSON.stringify(clineConfig, null, 2);
-}
-var init_cline = __esm({
-  "src/generators/mcp/cline.ts"() {
-    "use strict";
-  }
-});
-
-// src/generators/mcp/copilot.ts
-function generateCopilotMcp(config, target) {
-  const shouldInclude = (server) => {
-    const targets = server.rulesyncTargets;
-    if (!targets || targets.length === 0) return true;
-    if (targets.length === 1 && targets[0] === "*") return true;
-    return targets.includes("copilot");
-  };
-  const servers = {};
-  const inputs = [];
-  const inputMap = /* @__PURE__ */ new Map();
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const copilotServer = {};
-    if (server.command) {
-      copilotServer.command = server.command;
-      if (server.args) copilotServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        copilotServer.url = url;
-      }
-    }
-    if (server.env) {
-      copilotServer.env = {};
-      for (const [key, value] of Object.entries(server.env)) {
-        if (target === "editor" && value.includes("SECRET")) {
-          const inputId = `${serverName}_${key}`;
-          inputMap.set(inputId, value);
-          copilotServer.env[key] = `\${input:${inputId}}`;
-          inputs.push({
-            id: inputId,
-            type: "password",
-            description: `${key} for ${serverName}`
-          });
-        } else {
-          copilotServer.env[key] = value;
-        }
-      }
-    }
-    if (server.tools) {
-      copilotServer.tools = server.tools;
-    } else if (server.alwaysAllow) {
-      copilotServer.tools = server.alwaysAllow;
-    }
-    servers[serverName] = copilotServer;
-  }
-  if (target === "codingAgent") {
-    const config2 = { mcpServers: servers };
-    return JSON.stringify(config2, null, 2);
-  } else {
-    const config2 = { servers };
-    if (inputs.length > 0) {
-      config2.inputs = inputs;
-    }
-    return JSON.stringify(config2, null, 2);
-  }
-}
-var init_copilot = __esm({
-  "src/generators/mcp/copilot.ts"() {
-    "use strict";
-  }
-});
-
-// src/generators/mcp/cursor.ts
-function generateCursorMcp(config, _target) {
-  const cursorConfig = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    const targets = server.rulesyncTargets;
-    if (!targets || targets.length === 0) return true;
-    if (targets.length === 1 && targets[0] === "*") return true;
-    return targets.includes("cursor");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) 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);
-}
-var init_cursor = __esm({
-  "src/generators/mcp/cursor.ts"() {
-    "use strict";
-  }
-});
-
-// src/generators/mcp/geminicli.ts
-function generateGeminiCliMcp(config, _target) {
-  const geminiSettings = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    const targets = server.rulesyncTargets;
-    if (!targets || targets.length === 0) return true;
-    if (targets.length === 1 && targets[0] === "*") return true;
-    return targets.includes("geminicli");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) 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}}`;
-        }
-      }
-    }
-    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);
-}
-var init_geminicli = __esm({
-  "src/generators/mcp/geminicli.ts"() {
-    "use strict";
-  }
-});
-
-// src/generators/mcp/roo.ts
-function generateRooMcp(config, _target) {
-  const rooConfig = {
-    mcpServers: {}
-  };
-  const shouldInclude = (server) => {
-    const targets = server.rulesyncTargets;
-    if (!targets || targets.length === 0) return true;
-    if (targets.length === 1 && targets[0] === "*") return true;
-    return targets.includes("roo");
-  };
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldInclude(server)) continue;
-    const rooServer = {};
-    if (server.command) {
-      rooServer.command = server.command;
-      if (server.args) rooServer.args = server.args;
-    } else if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) {
-        rooServer.url = url;
-      }
-      if (server.httpUrl || server.transport === "http") {
-        rooServer.type = "streamable-http";
-      } else if (server.transport === "sse" || server.type === "sse") {
-        rooServer.type = "sse";
-      }
-    }
-    if (server.env) {
-      rooServer.env = {};
-      for (const [key, value] of Object.entries(server.env)) {
-        if (value.startsWith("${env:") && value.endsWith("}")) {
-          rooServer.env[key] = value;
-        } else {
-          rooServer.env[key] = `\${env:${value}}`;
-        }
-      }
-    }
-    if (server.disabled !== void 0) {
-      rooServer.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      rooServer.alwaysAllow = server.alwaysAllow;
-    }
-    if (server.networkTimeout !== void 0) {
-      rooServer.networkTimeout = Math.max(3e4, Math.min(3e5, server.networkTimeout));
-    }
-    rooConfig.mcpServers[serverName] = rooServer;
-  }
-  return JSON.stringify(rooConfig, null, 2);
-}
-var init_roo = __esm({
-  "src/generators/mcp/roo.ts"() {
-    "use strict";
-  }
-});
+import {
+  generateClaudeMcp
+} from "./chunk-LQDXGEGC.js";
+import {
+  generateClineMcp
+} from "./chunk-XERXHVPP.js";
+import {
+  generateCopilotMcp
+} from "./chunk-BEJD7I74.js";
+import {
+  generateCursorMcp
+} from "./chunk-VZMUQVX4.js";
+import {
+  generateGeminiCliMcp
+} from "./chunk-HOVR7QDA.js";
+import {
+  generateRooMcp
+} from "./chunk-SPMMXF7R.js";
+import "./chunk-AWKMUY5R.js";
 
 // src/cli/index.ts
-var import_commander = require("commander");
+import { Command } from "commander";
 
 // src/cli/commands/add.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"));
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
 
 // src/utils/config.ts
 function getDefaultConfig() {
@@ -380,10 +72,10 @@ 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`);
-    await (0, import_promises.mkdir)(rulesDir, { recursive: true });
+    const filePath = path.join(rulesDir, `${sanitizedFilename}.md`);
+    await mkdir(rulesDir, { recursive: true });
     const template = generateRuleTemplate(sanitizedFilename);
-    await (0, import_promises.writeFile)(filePath, template, "utf8");
+    await writeFile(filePath, template, "utf8");
     console.log(`\u2705 Created rule file: ${filePath}`);
     console.log(`\u{1F4DD} Edit the file to customize your rules.`);
   } catch (error) {
@@ -395,21 +87,47 @@ async function addCommand(filename) {
 }
 
 // src/generators/rules/claudecode.ts
-var import_node_path4 = require("path");
+import { join as join3 } from "path";
 
 // src/utils/file.ts
-var import_promises2 = require("fs/promises");
-var import_node_path3 = require("path");
+import { readdir, rm } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/utils/file-ops.ts
+import { mkdir as mkdir2, readFile, stat, writeFile as writeFile2 } from "fs/promises";
+import { dirname } from "path";
+async function ensureDir(dirPath) {
+  try {
+    await stat(dirPath);
+  } catch {
+    await mkdir2(dirPath, { recursive: true });
+  }
+}
+async function readFileContent(filepath) {
+  return readFile(filepath, "utf-8");
+}
+async function writeFileContent(filepath, content) {
+  await ensureDir(dirname(filepath));
+  await writeFile2(filepath, content, "utf-8");
+}
+async function fileExists(filepath) {
+  try {
+    await stat(filepath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/utils/ignore.ts
-var import_node_path2 = require("path");
-var import_micromatch = __toESM(require("micromatch"));
+import { join } from "path";
+import micromatch from "micromatch";
 var cachedIgnorePatterns = null;
 async function loadIgnorePatterns(baseDir = process.cwd()) {
   if (cachedIgnorePatterns) {
     return cachedIgnorePatterns;
   }
-  const ignorePath = (0, import_node_path2.join)(baseDir, ".rulesyncignore");
+  const ignorePath = join(baseDir, ".rulesyncignore");
   if (!await fileExists(ignorePath)) {
     cachedIgnorePatterns = { patterns: [] };
     return cachedIgnorePatterns;
@@ -434,12 +152,12 @@ function isFileIgnored(filepath, ignorePatterns) {
   }
   const negationPatterns = ignorePatterns.filter((p) => p.startsWith("!"));
   const positivePatterns = ignorePatterns.filter((p) => !p.startsWith("!"));
-  const isIgnored = positivePatterns.length > 0 && import_micromatch.default.isMatch(filepath, positivePatterns, {
+  const isIgnored = positivePatterns.length > 0 && micromatch.isMatch(filepath, positivePatterns, {
     dot: true
   });
   if (isIgnored && negationPatterns.length > 0) {
     const negationPatternsWithoutPrefix = negationPatterns.map((p) => p.substring(1));
-    return !import_micromatch.default.isMatch(filepath, negationPatternsWithoutPrefix, {
+    return !micromatch.isMatch(filepath, negationPatternsWithoutPrefix, {
       dot: true
     });
   }
@@ -453,24 +171,10 @@ function filterIgnoredFiles(files, ignorePatterns) {
 }
 
 // src/utils/file.ts
-async function ensureDir(dirPath) {
-  try {
-    await (0, import_promises2.stat)(dirPath);
-  } catch {
-    await (0, import_promises2.mkdir)(dirPath, { recursive: true });
-  }
-}
-async function readFileContent(filepath) {
-  return (0, import_promises2.readFile)(filepath, "utf-8");
-}
-async function writeFileContent(filepath, content) {
-  await ensureDir((0, import_node_path3.dirname)(filepath));
-  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
-}
 async function findFiles(dir, extension = ".md", ignorePatterns) {
   try {
-    const files = await (0, import_promises2.readdir)(dir);
-    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path3.join)(dir, file));
+    const files = await readdir(dir);
+    const filtered = files.filter((file) => file.endsWith(extension)).map((file) => join2(dir, file));
     if (ignorePatterns && ignorePatterns.length > 0) {
       return filterIgnoredFiles(filtered, ignorePatterns);
     }
@@ -479,14 +183,6 @@ async function findFiles(dir, extension = ".md", ignorePatterns) {
     return [];
   }
 }
-async function fileExists(filepath) {
-  try {
-    await (0, import_promises2.stat)(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function removeDirectory(dirPath) {
   const dangerousPaths = [".", "/", "~", "src", "node_modules"];
   if (dangerousPaths.includes(dirPath) || dirPath === "") {
@@ -495,7 +191,7 @@ async function removeDirectory(dirPath) {
   }
   try {
     if (await fileExists(dirPath)) {
-      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
+      await rm(dirPath, { recursive: true, force: true });
     }
   } catch (error) {
     console.warn(`Failed to remove directory ${dirPath}:`, error);
@@ -504,7 +200,7 @@ async function removeDirectory(dirPath) {
 async function removeFile(filepath) {
   try {
     if (await fileExists(filepath)) {
-      await (0, import_promises2.rm)(filepath);
+      await rm(filepath);
     }
   } catch (error) {
     console.warn(`Failed to remove file ${filepath}:`, error);
@@ -527,23 +223,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_path4.join)(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
+  const claudeOutputDir = baseDir ? join3(baseDir, config.outputPaths.claudecode) : config.outputPaths.claudecode;
   outputs.push({
     tool: "claudecode",
-    filepath: (0, import_node_path4.join)(claudeOutputDir, "CLAUDE.md"),
+    filepath: join3(claudeOutputDir, "CLAUDE.md"),
     content: claudeMdContent
   });
   for (const rule of detailRules) {
     const memoryContent = generateMemoryFile(rule);
     outputs.push({
       tool: "claudecode",
-      filepath: (0, import_node_path4.join)(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
+      filepath: join3(claudeOutputDir, ".claude", "memories", `${rule.filename}.md`),
       content: memoryContent
     });
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const settingsPath = baseDir ? (0, import_node_path4.join)(baseDir, ".claude", "settings.json") : (0, import_node_path4.join)(".claude", "settings.json");
+    const settingsPath = baseDir ? join3(baseDir, ".claude", "settings.json") : join3(".claude", "settings.json");
     await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
   }
   return outputs;
@@ -580,39 +276,46 @@ async function updateClaudeSettings(settingsPath, ignorePatterns) {
     try {
       const content = await readFileContent(settingsPath);
       settings = JSON.parse(content);
-    } catch (_error) {
+    } catch {
       console.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
       settings = {};
     }
   }
-  if (!settings.permissions) {
-    settings.permissions = {};
+  if (typeof settings !== "object" || settings === null) {
+    settings = {};
   }
-  if (!Array.isArray(settings.permissions.deny)) {
-    settings.permissions.deny = [];
+  const settingsObj = settings;
+  if (!settingsObj.permissions || typeof settingsObj.permissions !== "object" || settingsObj.permissions === null) {
+    settingsObj.permissions = {};
+  }
+  const permissions = settingsObj.permissions;
+  if (!Array.isArray(permissions.deny)) {
+    permissions.deny = [];
   }
   const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
-  settings.permissions.deny = settings.permissions.deny.filter((rule) => {
+  const denyArray = permissions.deny;
+  const filteredDeny = denyArray.filter((rule) => {
+    if (typeof rule !== "string") return false;
     if (!rule.startsWith("Read(")) return true;
     const match = rule.match(/^Read\((.*)\)$/);
     if (!match) return true;
     return !ignorePatterns.includes(match[1] ?? "");
   });
-  settings.permissions.deny.push(...readDenyRules);
-  settings.permissions.deny = [...new Set(settings.permissions.deny)];
-  const jsonContent = JSON.stringify(settings, null, 2);
+  filteredDeny.push(...readDenyRules);
+  permissions.deny = [...new Set(filteredDeny)];
+  const jsonContent = JSON.stringify(settingsObj, null, 2);
   await writeFileContent(settingsPath, jsonContent);
   console.log(`\u2705 Updated Claude Code settings: ${settingsPath}`);
 }
 
 // src/generators/rules/cline.ts
-var import_node_path5 = require("path");
+import { join as join4 } from "path";
 async function generateClineConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateClineMarkdown(rule);
-    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`);
+    const outputDir = baseDir ? join4(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
+    const filepath = join4(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "cline",
       filepath,
@@ -621,7 +324,7 @@ async function generateClineConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const clineIgnorePath = baseDir ? (0, import_node_path5.join)(baseDir, ".clineignore") : ".clineignore";
+    const clineIgnorePath = baseDir ? join4(baseDir, ".clineignore") : ".clineignore";
     const clineIgnoreContent = generateClineIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cline",
@@ -645,14 +348,14 @@ function generateClineIgnore(patterns) {
 }
 
 // src/generators/rules/copilot.ts
-var import_node_path6 = require("path");
+import { join as join5 } from "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_path6.join)(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
-    const filepath = (0, import_node_path6.join)(outputDir, `${baseFilename}.instructions.md`);
+    const outputDir = baseDir ? join5(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
+    const filepath = join5(outputDir, `${baseFilename}.instructions.md`);
     outputs.push({
       tool: "copilot",
       filepath,
@@ -661,7 +364,7 @@ async function generateCopilotConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const copilotIgnorePath = baseDir ? (0, import_node_path6.join)(baseDir, ".copilotignore") : ".copilotignore";
+    const copilotIgnorePath = baseDir ? join5(baseDir, ".copilotignore") : ".copilotignore";
     const copilotIgnoreContent = generateCopilotIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "copilot",
@@ -697,13 +400,13 @@ function generateCopilotIgnore(patterns) {
 }
 
 // src/generators/rules/cursor.ts
-var import_node_path7 = require("path");
+import { join as join6 } from "path";
 async function generateCursorConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateCursorMarkdown(rule);
-    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`);
+    const outputDir = baseDir ? join6(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
+    const filepath = join6(outputDir, `${rule.filename}.mdc`);
     outputs.push({
       tool: "cursor",
       filepath,
@@ -712,7 +415,7 @@ async function generateCursorConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const cursorIgnorePath = baseDir ? (0, import_node_path7.join)(baseDir, ".cursorignore") : ".cursorignore";
+    const cursorIgnorePath = baseDir ? join6(baseDir, ".cursorignore") : ".cursorignore";
     const cursorIgnoreContent = generateCursorIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "cursor",
@@ -753,15 +456,15 @@ function generateCursorIgnore(patterns) {
 }
 
 // src/generators/rules/geminicli.ts
-var import_node_path8 = require("path");
+import { join as join7 } from "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_path8.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = (0, import_node_path8.join)(outputDir, `${rule.filename}.md`);
+    const outputDir = baseDir ? join7(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
+    const filepath = join7(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "geminicli",
       filepath,
@@ -769,7 +472,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
     });
   }
   const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? (0, import_node_path8.join)(baseDir, "GEMINI.md") : "GEMINI.md";
+  const rootFilepath = baseDir ? join7(baseDir, "GEMINI.md") : "GEMINI.md";
   outputs.push({
     tool: "geminicli",
     filepath: rootFilepath,
@@ -777,7 +480,7 @@ async function generateGeminiConfig(rules, config, baseDir) {
   });
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const aiexcludePath = baseDir ? (0, import_node_path8.join)(baseDir, ".aiexclude") : ".aiexclude";
+    const aiexcludePath = baseDir ? join7(baseDir, ".aiexclude") : ".aiexclude";
     const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
     outputs.push({
       tool: "geminicli",
@@ -825,13 +528,13 @@ function generateAiexclude(patterns) {
 }
 
 // src/generators/rules/roo.ts
-var import_node_path9 = require("path");
+import { join as join8 } from "path";
 async function generateRooConfig(rules, config, baseDir) {
   const outputs = [];
   for (const rule of rules) {
     const content = generateRooMarkdown(rule);
-    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`);
+    const outputDir = baseDir ? join8(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
+    const filepath = join8(outputDir, `${rule.filename}.md`);
     outputs.push({
       tool: "roo",
       filepath,
@@ -840,7 +543,7 @@ async function generateRooConfig(rules, config, baseDir) {
   }
   const ignorePatterns = await loadIgnorePatterns(baseDir);
   if (ignorePatterns.patterns.length > 0) {
-    const rooIgnorePath = baseDir ? (0, import_node_path9.join)(baseDir, ".rooignore") : ".rooignore";
+    const rooIgnorePath = baseDir ? join8(baseDir, ".rooignore") : ".rooignore";
     const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
     outputs.push({
       tool: "roo",
@@ -913,8 +616,8 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path10 = require("path");
-var import_gray_matter = __toESM(require("gray-matter"));
+import { basename } from "path";
+import matter from "gray-matter";
 async function parseRulesFromDirectory(aiRulesDir) {
   const ignorePatterns = await loadIgnorePatterns();
   const ruleFiles = await findFiles(aiRulesDir, ".md", ignorePatterns.patterns);
@@ -947,10 +650,10 @@ ${errors.join("\n")}`);
 }
 async function parseRuleFile(filepath) {
   const content = await readFileContent(filepath);
-  const parsed = (0, import_gray_matter.default)(content);
+  const parsed = matter(content);
   validateFrontmatter(parsed.data, filepath);
   const frontmatter = parsed.data;
-  const filename = (0, import_node_path10.basename)(filepath, ".md");
+  const filename = basename(filepath, ".md");
   return {
     frontmatter,
     content: parsed.content,
@@ -1079,27 +782,19 @@ async function validateRule(rule) {
 }
 
 // src/core/mcp-generator.ts
-var import_node_os = __toESM(require("os"));
-var import_node_path12 = __toESM(require("path"));
-
-// src/generators/mcp/index.ts
-init_claude();
-init_cline();
-init_copilot();
-init_cursor();
-init_geminicli();
-init_roo();
+import os from "os";
+import path3 from "path";
 
 // src/core/mcp-parser.ts
-var import_node_fs = __toESM(require("fs"));
-var import_node_path11 = __toESM(require("path"));
+import fs from "fs";
+import path2 from "path";
 function parseMcpConfig(projectRoot) {
-  const mcpPath = import_node_path11.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;
@@ -1130,32 +825,32 @@ async function generateMcpConfigs(projectRoot, baseDir) {
   const generators = [
     {
       tool: "claude-project",
-      path: import_node_path12.default.join(targetRoot, ".mcp.json"),
+      path: path3.join(targetRoot, ".mcp.json"),
       generate: () => generateClaudeMcp(config, "project")
     },
     {
       tool: "copilot-editor",
-      path: import_node_path12.default.join(targetRoot, ".vscode", "mcp.json"),
+      path: path3.join(targetRoot, ".vscode", "mcp.json"),
       generate: () => generateCopilotMcp(config, "editor")
     },
     {
       tool: "cursor-project",
-      path: import_node_path12.default.join(targetRoot, ".cursor", "mcp.json"),
+      path: path3.join(targetRoot, ".cursor", "mcp.json"),
       generate: () => generateCursorMcp(config, "project")
     },
     {
       tool: "cline-project",
-      path: import_node_path12.default.join(targetRoot, ".cline", "mcp.json"),
+      path: path3.join(targetRoot, ".cline", "mcp.json"),
       generate: () => generateClineMcp(config, "project")
     },
     {
       tool: "gemini-project",
-      path: import_node_path12.default.join(targetRoot, ".gemini", "settings.json"),
+      path: path3.join(targetRoot, ".gemini", "settings.json"),
       generate: () => generateGeminiCliMcp(config, "project")
     },
     {
       tool: "roo-project",
-      path: import_node_path12.default.join(targetRoot, ".roo", "mcp.json"),
+      path: path3.join(targetRoot, ".roo", "mcp.json"),
       generate: () => generateRooMcp(config, "project")
     }
   ];
@@ -1163,17 +858,17 @@ async function generateMcpConfigs(projectRoot, baseDir) {
     generators.push(
       {
         tool: "claude-global",
-        path: import_node_path12.default.join(import_node_os.default.homedir(), ".claude", "settings.json"),
+        path: path3.join(os.homedir(), ".claude", "settings.json"),
         generate: () => generateClaudeMcp(config, "global")
       },
       {
         tool: "cursor-global",
-        path: import_node_path12.default.join(import_node_os.default.homedir(), ".cursor", "mcp.json"),
+        path: path3.join(os.homedir(), ".cursor", "mcp.json"),
         generate: () => generateCursorMcp(config, "global")
       },
       {
         tool: "gemini-global",
-        path: import_node_path12.default.join(import_node_os.default.homedir(), ".gemini", "settings.json"),
+        path: path3.join(os.homedir(), ".gemini", "settings.json"),
         generate: () => generateGeminiCliMcp(config, "global")
       }
     );
@@ -1331,10 +1026,10 @@ Generating configurations for base directory: ${baseDir}`);
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_fs2 = require("fs");
-var import_node_path13 = require("path");
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join as join9 } from "path";
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
+  const gitignorePath = join9(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
@@ -1352,6 +1047,7 @@ var gitignoreCommand = async () => {
     "**/.gemini/memories/",
     "**/.aiexclude",
     "**/.mcp.json",
+    "!.rulesync/.mcp.json",
     "**/.cursor/mcp.json",
     "**/.cline/mcp.json",
     "**/.vscode/mcp.json",
@@ -1359,8 +1055,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 (existsSync(gitignorePath)) {
+    gitignoreContent = readFileSync(gitignorePath, "utf-8");
   }
   const linesToAdd = [];
   for (const rule of rulesFilesToIgnore) {
@@ -1377,7 +1073,7 @@ var gitignoreCommand = async () => {
 ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
-  (0, import_node_fs2.writeFileSync)(gitignorePath, newContent);
+  writeFileSync(gitignorePath, newContent);
   console.log(`\u2705 .gitignore\u306B${linesToAdd.length}\u500B\u306E\u30EB\u30FC\u30EB\u3092\u8FFD\u52A0\u3057\u307E\u3057\u305F:`);
   for (const line of linesToAdd) {
     if (!line.startsWith("#")) {
@@ -1387,17 +1083,17 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path20 = require("path");
-var import_gray_matter4 = __toESM(require("gray-matter"));
+import { join as join16 } from "path";
+import matter4 from "gray-matter";
 
 // src/parsers/claudecode.ts
-var import_node_path14 = require("path");
+import { basename as basename2, join as join10 } from "path";
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const claudeFilePath = (0, import_node_path14.join)(baseDir, "CLAUDE.md");
+  const claudeFilePath = join10(baseDir, "CLAUDE.md");
   if (!await fileExists(claudeFilePath)) {
     errors.push("CLAUDE.md file not found");
     return { rules, errors };
@@ -1408,12 +1104,12 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path14.join)(baseDir, ".claude", "memories");
+    const memoryDir = join10(baseDir, ".claude", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseClaudeMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path14.join)(baseDir, ".claude", "settings.json");
+    const settingsPath = join10(baseDir, ".claude", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseClaudeSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1470,10 +1166,10 @@ async function parseClaudeMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path14.join)(memoryDir, file);
+        const filePath = join10(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path14.basename)(file, ".md");
+          const filename = basename2(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["claudecode"],
@@ -1489,7 +1185,7 @@ async function parseClaudeMemoryFiles(memoryDir) {
         }
       }
     }
-  } catch (_error) {
+  } catch {
   }
   return rules;
 }
@@ -1500,17 +1196,25 @@ async function parseClaudeSettings(settingsPath) {
   try {
     const content = await readFileContent(settingsPath);
     const settings = JSON.parse(content);
-    if (settings.permissions?.deny) {
-      const readPatterns = settings.permissions.deny.filter((rule) => rule.startsWith("Read(") && rule.endsWith(")")).map((rule) => {
-        const match = rule.match(/^Read\((.+)\)$/);
-        return match ? match[1] : null;
-      }).filter((pattern) => pattern !== null);
-      if (readPatterns.length > 0) {
-        ignorePatterns = readPatterns;
+    if (typeof settings === "object" && settings !== null && "permissions" in settings) {
+      const permissions = settings.permissions;
+      if (permissions && "deny" in permissions && Array.isArray(permissions.deny)) {
+        const readPatterns = permissions.deny.filter(
+          (rule) => typeof rule === "string" && rule.startsWith("Read(") && rule.endsWith(")")
+        ).map((rule) => {
+          const match = rule.match(/^Read\((.+)\)$/);
+          return match ? match[1] : null;
+        }).filter((pattern) => pattern !== null);
+        if (readPatterns.length > 0) {
+          ignorePatterns = readPatterns;
+        }
       }
     }
-    if (settings.mcpServers && Object.keys(settings.mcpServers).length > 0) {
-      mcpServers = settings.mcpServers;
+    if (typeof settings === "object" && settings !== null && "mcpServers" in settings) {
+      const servers = settings.mcpServers;
+      if (servers && typeof servers === "object" && Object.keys(servers).length > 0) {
+        mcpServers = servers;
+      }
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1524,11 +1228,11 @@ async function parseClaudeSettings(settingsPath) {
 }
 
 // src/parsers/cline.ts
-var import_node_path15 = require("path");
+import { join as join11 } from "path";
 async function parseClineConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const clineFilePath = (0, import_node_path15.join)(baseDir, ".cline", "instructions.md");
+  const clineFilePath = join11(baseDir, ".cline", "instructions.md");
   if (await fileExists(clineFilePath)) {
     try {
       const content = await readFileContent(clineFilePath);
@@ -1551,14 +1255,14 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
     }
   }
-  const clinerulesDirPath = (0, import_node_path15.join)(baseDir, ".clinerules");
+  const clinerulesDirPath = join11(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_path15.join)(clinerulesDirPath, file);
+          const filePath = join11(clinerulesDirPath, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -1594,16 +1298,16 @@ async function parseClineConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/copilot.ts
-var import_node_path16 = require("path");
-var import_gray_matter2 = __toESM(require("gray-matter"));
+import { basename as basename3, join as join12 } from "path";
+import matter2 from "gray-matter";
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const copilotFilePath = (0, import_node_path16.join)(baseDir, ".github", "copilot-instructions.md");
+  const copilotFilePath = join12(baseDir, ".github", "copilot-instructions.md");
   if (await fileExists(copilotFilePath)) {
     try {
       const rawContent = await readFileContent(copilotFilePath);
-      const parsed = (0, import_gray_matter2.default)(rawContent);
+      const parsed = matter2(rawContent);
       const content = parsed.content.trim();
       if (content) {
         const frontmatter = {
@@ -1624,19 +1328,19 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
     }
   }
-  const instructionsDir = (0, import_node_path16.join)(baseDir, ".github", "instructions");
+  const instructionsDir = join12(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_path16.join)(instructionsDir, file);
+          const filePath = join12(instructionsDir, file);
           const rawContent = await readFileContent(filePath);
-          const parsed = (0, import_gray_matter2.default)(rawContent);
+          const parsed = matter2(rawContent);
           const content = parsed.content.trim();
           if (content) {
-            const filename = (0, import_node_path16.basename)(file, ".instructions.md");
+            const filename = basename3(file, ".instructions.md");
             const frontmatter = {
               root: false,
               targets: ["copilot"],
@@ -1666,19 +1370,19 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path17 = require("path");
-var import_gray_matter3 = __toESM(require("gray-matter"));
-var import_js_yaml = __toESM(require("js-yaml"));
+import { basename as basename4, join as join13 } from "path";
+import matter3 from "gray-matter";
+import { DEFAULT_SCHEMA, FAILSAFE_SCHEMA, load } from "js-yaml";
 var customMatterOptions = {
   engines: {
     yaml: {
       parse: (str) => {
         try {
           const preprocessed = str.replace(/^(\s*globs:\s*)\*\s*$/gm, '$1"*"');
-          return import_js_yaml.default.load(preprocessed, { schema: import_js_yaml.default.DEFAULT_SCHEMA });
+          return load(preprocessed, { schema: DEFAULT_SCHEMA });
         } catch (error) {
           try {
-            return import_js_yaml.default.load(str, { schema: import_js_yaml.default.FAILSAFE_SCHEMA });
+            return load(str, { schema: FAILSAFE_SCHEMA });
           } catch {
             throw error;
           }
@@ -1692,11 +1396,11 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const cursorFilePath = (0, import_node_path17.join)(baseDir, ".cursorrules");
+  const cursorFilePath = join13(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
-      const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
+      const parsed = matter3(rawContent, customMatterOptions);
       const content = parsed.content.trim();
       if (content) {
         const frontmatter = {
@@ -1717,20 +1421,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 = join13(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 = join13(cursorRulesDir, file);
           try {
             const rawContent = await readFileContent(filePath);
-            const parsed = (0, import_gray_matter3.default)(rawContent, customMatterOptions);
+            const parsed = matter3(rawContent, customMatterOptions);
             const content = parsed.content.trim();
             if (content) {
-              const filename = (0, import_node_path17.basename)(file, ".mdc");
+              const filename = basename4(file, ".mdc");
               const frontmatter = {
                 root: false,
                 targets: ["cursor"],
@@ -1758,7 +1462,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 = join13(baseDir, ".cursorignore");
   if (await fileExists(cursorIgnorePath)) {
     try {
       const content = await readFileContent(cursorIgnorePath);
@@ -1771,7 +1475,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 = join13(baseDir, ".cursor", "mcp.json");
   if (await fileExists(cursorMcpPath)) {
     try {
       const content = await readFileContent(cursorMcpPath);
@@ -1793,13 +1497,13 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/geminicli.ts
-var import_node_path18 = require("path");
+import { basename as basename5, join as join14 } from "path";
 async function parseGeminiConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
   let ignorePatterns;
   let mcpServers;
-  const geminiFilePath = (0, import_node_path18.join)(baseDir, "GEMINI.md");
+  const geminiFilePath = join14(baseDir, "GEMINI.md");
   if (!await fileExists(geminiFilePath)) {
     errors.push("GEMINI.md file not found");
     return { rules, errors };
@@ -1810,12 +1514,12 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path18.join)(baseDir, ".gemini", "memories");
+    const memoryDir = join14(baseDir, ".gemini", "memories");
     if (await fileExists(memoryDir)) {
       const memoryRules = await parseGeminiMemoryFiles(memoryDir);
       rules.push(...memoryRules);
     }
-    const settingsPath = (0, import_node_path18.join)(baseDir, ".gemini", "settings.json");
+    const settingsPath = join14(baseDir, ".gemini", "settings.json");
     if (await fileExists(settingsPath)) {
       const settingsResult = await parseGeminiSettings(settingsPath);
       if (settingsResult.ignorePatterns) {
@@ -1826,7 +1530,7 @@ async function parseGeminiConfiguration(baseDir = process.cwd()) {
       }
       errors.push(...settingsResult.errors);
     }
-    const aiexcludePath = (0, import_node_path18.join)(baseDir, ".aiexclude");
+    const aiexcludePath = join14(baseDir, ".aiexclude");
     if (await fileExists(aiexcludePath)) {
       const aiexcludePatterns = await parseAiexclude(aiexcludePath);
       if (aiexcludePatterns.length > 0) {
@@ -1879,10 +1583,10 @@ async function parseGeminiMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path18.join)(memoryDir, file);
+        const filePath = join14(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path18.basename)(file, ".md");
+          const filename = basename5(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["geminicli"],
@@ -1898,7 +1602,7 @@ async function parseGeminiMemoryFiles(memoryDir) {
         }
       }
     }
-  } catch (_error) {
+  } catch {
   }
   return rules;
 }
@@ -1925,17 +1629,17 @@ async function parseAiexclude(aiexcludePath) {
     const content = await readFileContent(aiexcludePath);
     const patterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
     return patterns;
-  } catch (_error) {
+  } catch {
     return [];
   }
 }
 
 // src/parsers/roo.ts
-var import_node_path19 = require("path");
+import { join as join15 } from "path";
 async function parseRooConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const rooFilePath = (0, import_node_path19.join)(baseDir, ".roo", "instructions.md");
+  const rooFilePath = join15(baseDir, ".roo", "instructions.md");
   if (await fileExists(rooFilePath)) {
     try {
       const content = await readFileContent(rooFilePath);
@@ -1958,14 +1662,14 @@ async function parseRooConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
     }
   }
-  const rooRulesDir = (0, import_node_path19.join)(baseDir, ".roo", "rules");
+  const rooRulesDir = join15(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_path19.join)(rooRulesDir, file);
+          const filePath = join15(rooRulesDir, file);
           try {
             const content = await readFileContent(filePath);
             if (content.trim()) {
@@ -2066,7 +1770,7 @@ async function importConfiguration(options) {
   if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path20.join)(baseDir, rulesDir);
+  const rulesDirPath = join16(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -2080,7 +1784,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path20.join)(rulesDirPath, `${filename}.md`);
+      const filePath = join16(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -2095,7 +1799,7 @@ async function importConfiguration(options) {
   let ignoreFileCreated = false;
   if (ignorePatterns && ignorePatterns.length > 0) {
     try {
-      const rulesyncignorePath = (0, import_node_path20.join)(baseDir, ".rulesyncignore");
+      const rulesyncignorePath = join16(baseDir, ".rulesyncignore");
       const ignoreContent = `${ignorePatterns.join("\n")}
 `;
       await writeFileContent(rulesyncignorePath, ignoreContent);
@@ -2111,7 +1815,7 @@ async function importConfiguration(options) {
   let mcpFileCreated = false;
   if (mcpServers && Object.keys(mcpServers).length > 0) {
     try {
-      const mcpPath = (0, import_node_path20.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpPath = join16(baseDir, rulesDir, ".mcp.json");
       const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
 `;
       await writeFileContent(mcpPath, mcpContent);
@@ -2133,13 +1837,13 @@ async function importConfiguration(options) {
   };
 }
 function generateRuleFileContent(rule) {
-  const frontmatter = import_gray_matter4.default.stringify("", rule.frontmatter);
+  const frontmatter = matter4.stringify("", rule.frontmatter);
   return frontmatter + rule.content;
 }
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path20.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists(join16(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -2204,7 +1908,7 @@ async function importCommand(options = {}) {
 }
 
 // src/cli/commands/init.ts
-var import_node_path21 = require("path");
+import { join as join17 } from "path";
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -2334,7 +2038,7 @@ globs: ["src/api/**/*.ts", "src/services/**/*.ts", "src/models/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = (0, import_node_path21.join)(aiRulesDir, file.filename);
+    const filepath = join17(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);
@@ -2436,13 +2140,13 @@ async function validateCommand() {
 }
 
 // src/cli/commands/watch.ts
-var import_chokidar = __toESM(require("chokidar"));
+import { watch } from "chokidar";
 async function watchCommand() {
   const config = getDefaultConfig();
   console.log("\u{1F440} Watching for changes in .rulesync directory...");
   console.log("Press Ctrl+C to stop watching");
   await generateCommand({ verbose: false });
-  const watcher = import_chokidar.default.watch(`${config.aiRulesDir}/**/*.md`, {
+  const watcher = watch(`${config.aiRulesDir}/**/*.md`, {
     ignoreInitial: true,
     persistent: true
   });
@@ -2476,8 +2180,8 @@ 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.36.0");
+var program = new Command();
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.38.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);