rulesync 0.34.0 → 0.36.0

package/dist/index.js

@@ -6,6 +6,9 @@ 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))
@@ -23,6 +26,307 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   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";
+  }
+});
+
 // src/cli/index.ts
 var import_commander = require("commander");
 
@@ -39,11 +343,12 @@ function getDefaultConfig() {
       cursor: ".cursor/rules",
       cline: ".clinerules",
       claudecode: ".",
+      claude: ".",
       roo: ".roo/rules",
       geminicli: ".gemini/memories"
     },
     watchEnabled: false,
-    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "roo", "geminicli"]
+    defaultTargets: ["copilot", "cursor", "cline", "claudecode", "claude", "roo", "geminicli"]
   };
 }
 function resolveTargets(targets, config) {
@@ -89,27 +394,158 @@ async function addCommand(filename) {
   }
 }
 
-// src/generators/claudecode.ts
+// src/generators/rules/claudecode.ts
+var import_node_path4 = require("path");
+
+// src/utils/file.ts
+var import_promises2 = require("fs/promises");
+var import_node_path3 = require("path");
+
+// src/utils/ignore.ts
 var import_node_path2 = require("path");
+var import_micromatch = __toESM(require("micromatch"));
+var cachedIgnorePatterns = null;
+async function loadIgnorePatterns(baseDir = process.cwd()) {
+  if (cachedIgnorePatterns) {
+    return cachedIgnorePatterns;
+  }
+  const ignorePath = (0, import_node_path2.join)(baseDir, ".rulesyncignore");
+  if (!await fileExists(ignorePath)) {
+    cachedIgnorePatterns = { patterns: [] };
+    return cachedIgnorePatterns;
+  }
+  try {
+    const content = await readFileContent(ignorePath);
+    const patterns = parseIgnoreFile(content);
+    cachedIgnorePatterns = { patterns };
+    return cachedIgnorePatterns;
+  } catch (error) {
+    console.warn(`Failed to read .rulesyncignore: ${error}`);
+    cachedIgnorePatterns = { patterns: [] };
+    return cachedIgnorePatterns;
+  }
+}
+function parseIgnoreFile(content) {
+  return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+}
+function isFileIgnored(filepath, ignorePatterns) {
+  if (ignorePatterns.length === 0) {
+    return false;
+  }
+  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, {
+    dot: true
+  });
+  if (isIgnored && negationPatterns.length > 0) {
+    const negationPatternsWithoutPrefix = negationPatterns.map((p) => p.substring(1));
+    return !import_micromatch.default.isMatch(filepath, negationPatternsWithoutPrefix, {
+      dot: true
+    });
+  }
+  return isIgnored;
+}
+function filterIgnoredFiles(files, ignorePatterns) {
+  if (ignorePatterns.length === 0) {
+    return files;
+  }
+  return files.filter((file) => !isFileIgnored(file, 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));
+    if (ignorePatterns && ignorePatterns.length > 0) {
+      return filterIgnoredFiles(filtered, ignorePatterns);
+    }
+    return filtered;
+  } catch {
+    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 === "") {
+    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
+    return;
+  }
+  try {
+    if (await fileExists(dirPath)) {
+      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    console.warn(`Failed to remove directory ${dirPath}:`, error);
+  }
+}
+async function removeFile(filepath) {
+  try {
+    if (await fileExists(filepath)) {
+      await (0, import_promises2.rm)(filepath);
+    }
+  } catch (error) {
+    console.warn(`Failed to remove file ${filepath}:`, error);
+  }
+}
+async function removeClaudeGeneratedFiles() {
+  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
+  for (const fileOrDir of filesToRemove) {
+    if (fileOrDir.endsWith("/memories")) {
+      await removeDirectory(fileOrDir);
+    } else {
+      await removeFile(fileOrDir);
+    }
+  }
+}
+
+// src/generators/rules/claudecode.ts
 async function generateClaudecodeConfig(rules, config, baseDir) {
   const outputs = [];
   const rootRules = rules.filter((r) => r.frontmatter.root === true);
   const detailRules = rules.filter((r) => r.frontmatter.root === false);
   const claudeMdContent = generateClaudeMarkdown(rootRules, detailRules);
-  const claudeOutputDir = baseDir ? (0, import_node_path2.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_path2.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_path2.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_path4.join)(baseDir, ".claude", "settings.json") : (0, import_node_path4.join)(".claude", "settings.json");
+    await updateClaudeSettings(settingsPath, ignorePatterns.patterns);
+  }
   return outputs;
 }
 function generateClaudeMarkdown(rootRules, detailRules) {
@@ -138,42 +574,101 @@ function generateClaudeMarkdown(rootRules, detailRules) {
 function generateMemoryFile(rule) {
   return rule.content.trim();
 }
+async function updateClaudeSettings(settingsPath, ignorePatterns) {
+  let settings = {};
+  if (await fileExists(settingsPath)) {
+    try {
+      const content = await readFileContent(settingsPath);
+      settings = JSON.parse(content);
+    } catch (_error) {
+      console.warn(`Failed to parse existing ${settingsPath}, creating new settings`);
+      settings = {};
+    }
+  }
+  if (!settings.permissions) {
+    settings.permissions = {};
+  }
+  if (!Array.isArray(settings.permissions.deny)) {
+    settings.permissions.deny = [];
+  }
+  const readDenyRules = ignorePatterns.map((pattern) => `Read(${pattern})`);
+  settings.permissions.deny = 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] ?? "");
+  });
+  settings.permissions.deny.push(...readDenyRules);
+  settings.permissions.deny = [...new Set(settings.permissions.deny)];
+  const jsonContent = JSON.stringify(settings, null, 2);
+  await writeFileContent(settingsPath, jsonContent);
+  console.log(`\u2705 Updated Claude Code settings: ${settingsPath}`);
+}
 
-// src/generators/cline.ts
-var import_node_path3 = require("path");
+// src/generators/rules/cline.ts
+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_path3.join)(baseDir, config.outputPaths.cline) : config.outputPaths.cline;
-    const filepath = (0, import_node_path3.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,
       content
     });
   }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const clineIgnorePath = baseDir ? (0, import_node_path5.join)(baseDir, ".clineignore") : ".clineignore";
+    const clineIgnoreContent = generateClineIgnore(ignorePatterns.patterns);
+    outputs.push({
+      tool: "cline",
+      filepath: clineIgnorePath,
+      content: clineIgnoreContent
+    });
+  }
   return outputs;
 }
 function generateClineMarkdown(rule) {
   return rule.content.trim();
 }
+function generateClineIgnore(patterns) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually.",
+    "",
+    ...patterns
+  ];
+  return lines.join("\n");
+}
 
-// src/generators/copilot.ts
-var import_node_path4 = require("path");
+// src/generators/rules/copilot.ts
+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_path4.join)(baseDir, config.outputPaths.copilot) : config.outputPaths.copilot;
-    const filepath = (0, import_node_path4.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,
       content
     });
   }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const copilotIgnorePath = baseDir ? (0, import_node_path6.join)(baseDir, ".copilotignore") : ".copilotignore";
+    const copilotIgnoreContent = generateCopilotIgnore(ignorePatterns.patterns);
+    outputs.push({
+      tool: "copilot",
+      filepath: copilotIgnorePath,
+      content: copilotIgnoreContent
+    });
+  }
   return outputs;
 }
 function generateCopilotMarkdown(rule) {
@@ -189,21 +684,42 @@ function generateCopilotMarkdown(rule) {
   lines.push(rule.content);
   return lines.join("\n");
 }
+function generateCopilotIgnore(patterns) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually.",
+    "# Note: .copilotignore is not officially supported by GitHub Copilot.",
+    "# This file is for use with community tools like copilotignore-vscode extension.",
+    "",
+    ...patterns
+  ];
+  return lines.join("\n");
+}
 
-// src/generators/cursor.ts
-var import_node_path5 = require("path");
+// src/generators/rules/cursor.ts
+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_path5.join)(baseDir, config.outputPaths.cursor) : config.outputPaths.cursor;
-    const filepath = (0, import_node_path5.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,
       content
     });
   }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const cursorIgnorePath = baseDir ? (0, import_node_path7.join)(baseDir, ".cursorignore") : ".cursorignore";
+    const cursorIgnoreContent = generateCursorIgnore(ignorePatterns.patterns);
+    outputs.push({
+      tool: "cursor",
+      filepath: cursorIgnorePath,
+      content: cursorIgnoreContent
+    });
+  }
   return outputs;
 }
 function generateCursorMarkdown(rule) {
@@ -226,17 +742,26 @@ function generateCursorMarkdown(rule) {
   lines.push(rule.content);
   return lines.join("\n");
 }
+function generateCursorIgnore(patterns) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually.",
+    "",
+    ...patterns
+  ];
+  return lines.join("\n");
+}
 
-// src/generators/geminicli.ts
-var import_node_path6 = require("path");
+// src/generators/rules/geminicli.ts
+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_path6.join)(baseDir, config.outputPaths.geminicli) : config.outputPaths.geminicli;
-    const filepath = (0, import_node_path6.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,
@@ -244,12 +769,22 @@ async function generateGeminiConfig(rules, config, baseDir) {
     });
   }
   const rootContent = generateGeminiRootMarkdown(rootRule, memoryRules, baseDir);
-  const rootFilepath = baseDir ? (0, import_node_path6.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,
     content: rootContent
   });
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const aiexcludePath = baseDir ? (0, import_node_path8.join)(baseDir, ".aiexclude") : ".aiexclude";
+    const aiexcludeContent = generateAiexclude(ignorePatterns.patterns);
+    outputs.push({
+      tool: "geminicli",
+      filepath: aiexcludePath,
+      content: aiexcludeContent
+    });
+  }
   return outputs;
 }
 function generateGeminiMemoryMarkdown(rule) {
@@ -279,92 +814,53 @@ function generateGeminiRootMarkdown(rootRule, memoryRules, _baseDir) {
   }
   return lines.join("\n");
 }
+function generateAiexclude(patterns) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually.",
+    "",
+    ...patterns
+  ];
+  return lines.join("\n");
+}
 
-// src/generators/roo.ts
-var import_node_path7 = require("path");
+// src/generators/rules/roo.ts
+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_path7.join)(baseDir, config.outputPaths.roo) : config.outputPaths.roo;
-    const filepath = (0, import_node_path7.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,
       content
     });
   }
+  const ignorePatterns = await loadIgnorePatterns(baseDir);
+  if (ignorePatterns.patterns.length > 0) {
+    const rooIgnorePath = baseDir ? (0, import_node_path9.join)(baseDir, ".rooignore") : ".rooignore";
+    const rooIgnoreContent = generateRooIgnore(ignorePatterns.patterns);
+    outputs.push({
+      tool: "roo",
+      filepath: rooIgnorePath,
+      content: rooIgnoreContent
+    });
+  }
   return outputs;
 }
 function generateRooMarkdown(rule) {
   return rule.content.trim();
 }
-
-// src/utils/file.ts
-var import_promises2 = require("fs/promises");
-var import_node_path8 = require("path");
-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_path8.dirname)(filepath));
-  await (0, import_promises2.writeFile)(filepath, content, "utf-8");
-}
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await (0, import_promises2.readdir)(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => (0, import_node_path8.join)(dir, file));
-  } catch {
-    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 === "") {
-    console.warn(`Skipping deletion of dangerous path: ${dirPath}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await (0, import_promises2.rm)(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    console.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await (0, import_promises2.rm)(filepath);
-    }
-  } catch (error) {
-    console.warn(`Failed to remove file ${filepath}:`, error);
-  }
-}
-async function removeClaudeGeneratedFiles() {
-  const filesToRemove = ["CLAUDE.md", ".claude/memories"];
-  for (const fileOrDir of filesToRemove) {
-    if (fileOrDir.endsWith("/memories")) {
-      await removeDirectory(fileOrDir);
-    } else {
-      await removeFile(fileOrDir);
-    }
-  }
+function generateRooIgnore(patterns) {
+  const lines = [
+    "# Generated by rulesync from .rulesyncignore",
+    "# This file is automatically generated. Do not edit manually.",
+    "",
+    ...patterns
+  ];
+  return lines.join("\n");
 }
 
 // src/core/generator.ts
@@ -417,12 +913,16 @@ async function generateForTool(tool, rules, config, baseDir) {
 }
 
 // src/core/parser.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 var import_gray_matter = __toESM(require("gray-matter"));
 async function parseRulesFromDirectory(aiRulesDir) {
-  const ruleFiles = await findFiles(aiRulesDir);
+  const ignorePatterns = await loadIgnorePatterns();
+  const ruleFiles = await findFiles(aiRulesDir, ".md", ignorePatterns.patterns);
   const rules = [];
   const errors = [];
+  if (ignorePatterns.patterns.length > 0) {
+    console.log(`Loaded ${ignorePatterns.patterns.length} ignore patterns from .rulesyncignore`);
+  }
   for (const filepath of ruleFiles) {
     try {
       const rule = await parseRuleFile(filepath);
@@ -450,7 +950,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_path9.basename)(filepath, ".md");
+  const filename = (0, import_node_path10.basename)(filepath, ".md");
   return {
     frontmatter,
     content: parsed.content,
@@ -578,6 +1078,148 @@ 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();
+
+// src/core/mcp-parser.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path11 = __toESM(require("path"));
+function parseMcpConfig(projectRoot) {
+  const mcpPath = import_node_path11.default.join(projectRoot, ".rulesync", ".mcp.json");
+  if (!import_node_fs.default.existsSync(mcpPath)) {
+    return null;
+  }
+  try {
+    const content = import_node_fs.default.readFileSync(mcpPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    if (rawConfig.servers && !rawConfig.mcpServers) {
+      rawConfig.mcpServers = rawConfig.servers;
+      delete rawConfig.servers;
+    }
+    if (!rawConfig.mcpServers || typeof rawConfig.mcpServers !== "object") {
+      throw new Error("Invalid mcp.json: 'mcpServers' field must be an object");
+    }
+    if (rawConfig.tools) {
+      delete rawConfig.tools;
+    }
+    return { mcpServers: rawConfig.mcpServers };
+  } catch (error) {
+    throw new Error(
+      `Failed to parse mcp.json: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/core/mcp-generator.ts
+async function generateMcpConfigs(projectRoot, baseDir) {
+  const results = [];
+  const targetRoot = baseDir || projectRoot;
+  const config = parseMcpConfig(projectRoot);
+  if (!config) {
+    return results;
+  }
+  const generators = [
+    {
+      tool: "claude-project",
+      path: import_node_path12.default.join(targetRoot, ".mcp.json"),
+      generate: () => generateClaudeMcp(config, "project")
+    },
+    {
+      tool: "copilot-editor",
+      path: import_node_path12.default.join(targetRoot, ".vscode", "mcp.json"),
+      generate: () => generateCopilotMcp(config, "editor")
+    },
+    {
+      tool: "cursor-project",
+      path: import_node_path12.default.join(targetRoot, ".cursor", "mcp.json"),
+      generate: () => generateCursorMcp(config, "project")
+    },
+    {
+      tool: "cline-project",
+      path: import_node_path12.default.join(targetRoot, ".cline", "mcp.json"),
+      generate: () => generateClineMcp(config, "project")
+    },
+    {
+      tool: "gemini-project",
+      path: import_node_path12.default.join(targetRoot, ".gemini", "settings.json"),
+      generate: () => generateGeminiCliMcp(config, "project")
+    },
+    {
+      tool: "roo-project",
+      path: import_node_path12.default.join(targetRoot, ".roo", "mcp.json"),
+      generate: () => generateRooMcp(config, "project")
+    }
+  ];
+  if (!baseDir) {
+    generators.push(
+      {
+        tool: "claude-global",
+        path: import_node_path12.default.join(import_node_os.default.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"),
+        generate: () => generateCursorMcp(config, "global")
+      },
+      {
+        tool: "gemini-global",
+        path: import_node_path12.default.join(import_node_os.default.homedir(), ".gemini", "settings.json"),
+        generate: () => generateGeminiCliMcp(config, "global")
+      }
+    );
+  }
+  for (const generator of generators) {
+    try {
+      const content = generator.generate();
+      const parsed = JSON.parse(content);
+      if (generator.tool.includes("claude") || generator.tool.includes("cline") || generator.tool.includes("cursor") || generator.tool.includes("gemini") || generator.tool.includes("roo")) {
+        if (!parsed.mcpServers || Object.keys(parsed.mcpServers).length === 0) {
+          results.push({
+            tool: generator.tool,
+            path: generator.path,
+            status: "skipped"
+          });
+          continue;
+        }
+      } else if (generator.tool.includes("copilot")) {
+        const key = generator.tool.includes("codingAgent") ? "mcpServers" : "servers";
+        if (!parsed[key] || Object.keys(parsed[key]).length === 0) {
+          results.push({
+            tool: generator.tool,
+            path: generator.path,
+            status: "skipped"
+          });
+          continue;
+        }
+      }
+      await writeFileContent(generator.path, content);
+      results.push({
+        tool: generator.tool,
+        path: generator.path,
+        status: "success"
+      });
+    } catch (error) {
+      results.push({
+        tool: generator.tool,
+        path: generator.path,
+        status: "error",
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return results;
+}
+
 // src/cli/commands/generate.ts
 async function generateCommand(options = {}) {
   const config = getDefaultConfig();
@@ -658,6 +1300,30 @@ Generating configurations for base directory: ${baseDir}`);
     }
     console.log(`
 \u{1F389} Successfully generated ${totalOutputs} configuration file(s)!`);
+    if (options.verbose) {
+      console.log("\nGenerating MCP configurations...");
+    }
+    for (const baseDir of baseDirs) {
+      const mcpResults = await generateMcpConfigs(
+        process.cwd(),
+        baseDir === process.cwd() ? void 0 : baseDir
+      );
+      if (mcpResults.length === 0) {
+        if (options.verbose) {
+          console.log(`No MCP configuration found for ${baseDir}`);
+        }
+        continue;
+      }
+      for (const result of mcpResults) {
+        if (result.status === "success") {
+          console.log(`\u2705 Generated ${result.tool} MCP configuration: ${result.path}`);
+        } else if (result.status === "error") {
+          console.error(`\u274C Failed to generate ${result.tool} MCP configuration: ${result.error}`);
+        } else if (options.verbose && result.status === "skipped") {
+          console.log(`\u23ED\uFE0F  Skipped ${result.tool} MCP configuration (no servers configured)`);
+        }
+      }
+    }
   } catch (error) {
     console.error("\u274C Failed to generate configurations:", error);
     process.exit(1);
@@ -665,25 +1331,36 @@ Generating configurations for base directory: ${baseDir}`);
 }
 
 // src/cli/commands/gitignore.ts
-var import_node_fs = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs2 = require("fs");
+var import_node_path13 = require("path");
 var gitignoreCommand = async () => {
-  const gitignorePath = (0, import_node_path10.join)(process.cwd(), ".gitignore");
+  const gitignorePath = (0, import_node_path13.join)(process.cwd(), ".gitignore");
   const rulesFilesToIgnore = [
     "# Generated by rulesync - AI tool configuration files",
     "**/.github/copilot-instructions.md",
     "**/.github/instructions/",
     "**/.cursor/rules/",
+    "**/.cursorignore",
     "**/.clinerules/",
+    "**/.clineignore",
     "**/CLAUDE.md",
     "**/.claude/memories/",
     "**/.roo/rules/",
+    "**/.rooignore",
+    "**/.copilotignore",
     "**/GEMINI.md",
-    "**/.gemini/memories/"
+    "**/.gemini/memories/",
+    "**/.aiexclude",
+    "**/.mcp.json",
+    "**/.cursor/mcp.json",
+    "**/.cline/mcp.json",
+    "**/.vscode/mcp.json",
+    "**/.gemini/settings.json",
+    "**/.roo/mcp.json"
   ];
   let gitignoreContent = "";
-  if ((0, import_node_fs.existsSync)(gitignorePath)) {
-    gitignoreContent = (0, import_node_fs.readFileSync)(gitignorePath, "utf-8");
+  if ((0, import_node_fs2.existsSync)(gitignorePath)) {
+    gitignoreContent = (0, import_node_fs2.readFileSync)(gitignorePath, "utf-8");
   }
   const linesToAdd = [];
   for (const rule of rulesFilesToIgnore) {
@@ -700,7 +1377,7 @@ var gitignoreCommand = async () => {
 ${linesToAdd.join("\n")}
 ` : `${linesToAdd.join("\n")}
 `;
-  (0, import_node_fs.writeFileSync)(gitignorePath, newContent);
+  (0, import_node_fs2.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("#")) {
@@ -710,15 +1387,17 @@ ${linesToAdd.join("\n")}
 };
 
 // src/core/importer.ts
-var import_node_path16 = require("path");
+var import_node_path20 = require("path");
 var import_gray_matter4 = __toESM(require("gray-matter"));
 
 // src/parsers/claudecode.ts
-var import_node_path11 = require("path");
+var import_node_path14 = require("path");
 async function parseClaudeConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const claudeFilePath = (0, import_node_path11.join)(baseDir, "CLAUDE.md");
+  let ignorePatterns;
+  let mcpServers;
+  const claudeFilePath = (0, import_node_path14.join)(baseDir, "CLAUDE.md");
   if (!await fileExists(claudeFilePath)) {
     errors.push("CLAUDE.md file not found");
     return { rules, errors };
@@ -729,16 +1408,32 @@ async function parseClaudeConfiguration(baseDir = process.cwd()) {
     if (mainRule) {
       rules.push(mainRule);
     }
-    const memoryDir = (0, import_node_path11.join)(baseDir, ".claude", "memories");
+    const memoryDir = (0, import_node_path14.join)(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");
+    if (await fileExists(settingsPath)) {
+      const settingsResult = await parseClaudeSettings(settingsPath);
+      if (settingsResult.ignorePatterns) {
+        ignorePatterns = settingsResult.ignorePatterns;
+      }
+      if (settingsResult.mcpServers) {
+        mcpServers = settingsResult.mcpServers;
+      }
+      errors.push(...settingsResult.errors);
+    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     errors.push(`Failed to parse Claude configuration: ${errorMessage}`);
   }
-  return { rules, errors };
+  return {
+    rules,
+    errors,
+    ...ignorePatterns && { ignorePatterns },
+    ...mcpServers && { mcpServers }
+  };
 }
 function parseClaudeMainFile(content, filepath) {
   const lines = content.split("\n");
@@ -775,10 +1470,10 @@ async function parseClaudeMemoryFiles(memoryDir) {
     const files = await readdir2(memoryDir);
     for (const file of files) {
       if (file.endsWith(".md")) {
-        const filePath = (0, import_node_path11.join)(memoryDir, file);
+        const filePath = (0, import_node_path14.join)(memoryDir, file);
         const content = await readFileContent(filePath);
         if (content.trim()) {
-          const filename = (0, import_node_path11.basename)(file, ".md");
+          const filename = (0, import_node_path14.basename)(file, ".md");
           const frontmatter = {
             root: false,
             targets: ["claudecode"],
@@ -798,47 +1493,113 @@ async function parseClaudeMemoryFiles(memoryDir) {
   }
   return rules;
 }
+async function parseClaudeSettings(settingsPath) {
+  const errors = [];
+  let ignorePatterns;
+  let mcpServers;
+  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 (settings.mcpServers && Object.keys(settings.mcpServers).length > 0) {
+      mcpServers = settings.mcpServers;
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to parse settings.json: ${errorMessage}`);
+  }
+  return {
+    errors,
+    ...ignorePatterns && { ignorePatterns },
+    ...mcpServers && { mcpServers }
+  };
+}
 
 // src/parsers/cline.ts
-var import_node_path12 = require("path");
+var import_node_path15 = require("path");
 async function parseClineConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const clineFilePath = (0, import_node_path12.join)(baseDir, ".cline", "instructions.md");
-  if (!await fileExists(clineFilePath)) {
-    errors.push(".cline/instructions.md file not found");
-    return { rules, errors };
+  const clineFilePath = (0, import_node_path15.join)(baseDir, ".cline", "instructions.md");
+  if (await fileExists(clineFilePath)) {
+    try {
+      const content = await readFileContent(clineFilePath);
+      if (content.trim()) {
+        const frontmatter = {
+          root: false,
+          targets: ["cline"],
+          description: "Cline instructions",
+          globs: ["**/*"]
+        };
+        rules.push({
+          frontmatter,
+          content: content.trim(),
+          filename: "cline-instructions",
+          filepath: clineFilePath
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .cline/instructions.md: ${errorMessage}`);
+    }
   }
-  try {
-    const content = await readFileContent(clineFilePath);
-    if (content.trim()) {
-      const frontmatter = {
-        root: false,
-        targets: ["cline"],
-        description: "Cline AI assistant instructions",
-        globs: ["**/*"]
-      };
-      rules.push({
-        frontmatter,
-        content: content.trim(),
-        filename: "cline-instructions",
-        filepath: clineFilePath
-      });
+  const clinerulesDirPath = (0, import_node_path15.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_path15.join)(clinerulesDirPath, file);
+          try {
+            const content = await readFileContent(filePath);
+            if (content.trim()) {
+              const filename = file.replace(".md", "");
+              const frontmatter = {
+                root: false,
+                targets: ["cline"],
+                description: `Cline rule: ${filename}`,
+                globs: ["**/*"]
+              };
+              rules.push({
+                frontmatter,
+                content: content.trim(),
+                filename: `cline-${filename}`,
+                filepath: filePath
+              });
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .clinerules files: ${errorMessage}`);
     }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    errors.push(`Failed to parse Cline configuration: ${errorMessage}`);
+  }
+  if (rules.length === 0) {
+    errors.push("No Cline configuration files found (.cline/instructions.md or .clinerules/*.md)");
   }
   return { rules, errors };
 }
 
 // src/parsers/copilot.ts
-var import_node_path13 = require("path");
+var import_node_path16 = require("path");
 var import_gray_matter2 = __toESM(require("gray-matter"));
 async function parseCopilotConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const copilotFilePath = (0, import_node_path13.join)(baseDir, ".github", "copilot-instructions.md");
+  const copilotFilePath = (0, import_node_path16.join)(baseDir, ".github", "copilot-instructions.md");
   if (await fileExists(copilotFilePath)) {
     try {
       const rawContent = await readFileContent(copilotFilePath);
@@ -863,19 +1624,19 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse copilot-instructions.md: ${errorMessage}`);
     }
   }
-  const instructionsDir = (0, import_node_path13.join)(baseDir, ".github", "instructions");
+  const instructionsDir = (0, import_node_path16.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_path13.join)(instructionsDir, file);
+          const filePath = (0, import_node_path16.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_path13.basename)(file, ".instructions.md");
+            const filename = (0, import_node_path16.basename)(file, ".instructions.md");
             const frontmatter = {
               root: false,
               targets: ["copilot"],
@@ -905,7 +1666,7 @@ async function parseCopilotConfiguration(baseDir = process.cwd()) {
 }
 
 // src/parsers/cursor.ts
-var import_node_path14 = require("path");
+var import_node_path17 = require("path");
 var import_gray_matter3 = __toESM(require("gray-matter"));
 var import_js_yaml = __toESM(require("js-yaml"));
 var customMatterOptions = {
@@ -929,7 +1690,9 @@ var customMatterOptions = {
 async function parseCursorConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const cursorFilePath = (0, import_node_path14.join)(baseDir, ".cursorrules");
+  let ignorePatterns;
+  let mcpServers;
+  const cursorFilePath = (0, import_node_path17.join)(baseDir, ".cursorrules");
   if (await fileExists(cursorFilePath)) {
     try {
       const rawContent = await readFileContent(cursorFilePath);
@@ -954,20 +1717,20 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
       errors.push(`Failed to parse .cursorrules file: ${errorMessage}`);
     }
   }
-  const cursorRulesDir = (0, import_node_path14.join)(baseDir, ".cursor", "rules");
+  const cursorRulesDir = (0, import_node_path17.join)(baseDir, ".cursor", "rules");
   if (await fileExists(cursorRulesDir)) {
     try {
       const { readdir: readdir2 } = await import("fs/promises");
       const files = await readdir2(cursorRulesDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = (0, import_node_path14.join)(cursorRulesDir, file);
+          const filePath = (0, import_node_path17.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_path14.basename)(file, ".mdc");
+              const filename = (0, import_node_path17.basename)(file, ".mdc");
               const frontmatter = {
                 root: false,
                 targets: ["cursor"],
@@ -995,38 +1758,244 @@ async function parseCursorConfiguration(baseDir = process.cwd()) {
   if (rules.length === 0) {
     errors.push("No Cursor configuration files found (.cursorrules or .cursor/rules/*.mdc)");
   }
-  return { rules, errors };
+  const cursorIgnorePath = (0, import_node_path17.join)(baseDir, ".cursorignore");
+  if (await fileExists(cursorIgnorePath)) {
+    try {
+      const content = await readFileContent(cursorIgnorePath);
+      const patterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+      if (patterns.length > 0) {
+        ignorePatterns = patterns;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .cursorignore: ${errorMessage}`);
+    }
+  }
+  const cursorMcpPath = (0, import_node_path17.join)(baseDir, ".cursor", "mcp.json");
+  if (await fileExists(cursorMcpPath)) {
+    try {
+      const content = await readFileContent(cursorMcpPath);
+      const mcp = JSON.parse(content);
+      if (mcp.mcpServers && Object.keys(mcp.mcpServers).length > 0) {
+        mcpServers = mcp.mcpServers;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .cursor/mcp.json: ${errorMessage}`);
+    }
+  }
+  return {
+    rules,
+    errors,
+    ...ignorePatterns && { ignorePatterns },
+    ...mcpServers && { mcpServers }
+  };
 }
 
-// src/parsers/roo.ts
-var import_node_path15 = require("path");
-async function parseRooConfiguration(baseDir = process.cwd()) {
+// src/parsers/geminicli.ts
+var import_node_path18 = require("path");
+async function parseGeminiConfiguration(baseDir = process.cwd()) {
   const errors = [];
   const rules = [];
-  const rooFilePath = (0, import_node_path15.join)(baseDir, ".roo", "instructions.md");
-  if (!await fileExists(rooFilePath)) {
-    errors.push(".roo/instructions.md file not found");
+  let ignorePatterns;
+  let mcpServers;
+  const geminiFilePath = (0, import_node_path18.join)(baseDir, "GEMINI.md");
+  if (!await fileExists(geminiFilePath)) {
+    errors.push("GEMINI.md file not found");
     return { rules, errors };
   }
   try {
-    const content = await readFileContent(rooFilePath);
-    if (content.trim()) {
-      const frontmatter = {
-        root: false,
-        targets: ["roo"],
-        description: "Roo Code AI assistant instructions",
-        globs: ["**/*"]
-      };
-      rules.push({
-        frontmatter,
-        content: content.trim(),
-        filename: "roo-instructions",
-        filepath: rooFilePath
-      });
+    const geminiContent = await readFileContent(geminiFilePath);
+    const mainRule = parseGeminiMainFile(geminiContent, geminiFilePath);
+    if (mainRule) {
+      rules.push(mainRule);
+    }
+    const memoryDir = (0, import_node_path18.join)(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");
+    if (await fileExists(settingsPath)) {
+      const settingsResult = await parseGeminiSettings(settingsPath);
+      if (settingsResult.ignorePatterns) {
+        ignorePatterns = settingsResult.ignorePatterns;
+      }
+      if (settingsResult.mcpServers) {
+        mcpServers = settingsResult.mcpServers;
+      }
+      errors.push(...settingsResult.errors);
+    }
+    const aiexcludePath = (0, import_node_path18.join)(baseDir, ".aiexclude");
+    if (await fileExists(aiexcludePath)) {
+      const aiexcludePatterns = await parseAiexclude(aiexcludePath);
+      if (aiexcludePatterns.length > 0) {
+        ignorePatterns = ignorePatterns ? [...ignorePatterns, ...aiexcludePatterns] : aiexcludePatterns;
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push(`Failed to parse Gemini configuration: ${errorMessage}`);
+  }
+  return {
+    rules,
+    errors,
+    ...ignorePatterns && { ignorePatterns },
+    ...mcpServers && { mcpServers }
+  };
+}
+function parseGeminiMainFile(content, filepath) {
+  const lines = content.split("\n");
+  let contentStartIndex = 0;
+  if (lines.some((line) => line.includes("| Document | Description | File Patterns |"))) {
+    const tableEndIndex = lines.findIndex(
+      (line, index) => index > 0 && line.trim() === "" && lines[index - 1]?.includes("|") && !lines[index + 1]?.includes("|")
+    );
+    if (tableEndIndex !== -1) {
+      contentStartIndex = tableEndIndex + 1;
+    }
+  }
+  const mainContent = lines.slice(contentStartIndex).join("\n").trim();
+  if (!mainContent) {
+    return null;
+  }
+  const frontmatter = {
+    root: false,
+    targets: ["geminicli"],
+    description: "Main Gemini CLI configuration",
+    globs: ["**/*"]
+  };
+  return {
+    frontmatter,
+    content: mainContent,
+    filename: "gemini-main",
+    filepath
+  };
+}
+async function parseGeminiMemoryFiles(memoryDir) {
+  const rules = [];
+  try {
+    const { readdir: readdir2 } = await import("fs/promises");
+    const files = await readdir2(memoryDir);
+    for (const file of files) {
+      if (file.endsWith(".md")) {
+        const filePath = (0, import_node_path18.join)(memoryDir, file);
+        const content = await readFileContent(filePath);
+        if (content.trim()) {
+          const filename = (0, import_node_path18.basename)(file, ".md");
+          const frontmatter = {
+            root: false,
+            targets: ["geminicli"],
+            description: `Memory file: ${filename}`,
+            globs: ["**/*"]
+          };
+          rules.push({
+            frontmatter,
+            content: content.trim(),
+            filename: `gemini-memory-${filename}`,
+            filepath: filePath
+          });
+        }
+      }
+    }
+  } catch (_error) {
+  }
+  return rules;
+}
+async function parseGeminiSettings(settingsPath) {
+  const errors = [];
+  let mcpServers;
+  try {
+    const content = await readFileContent(settingsPath);
+    const settings = JSON.parse(content);
+    if (settings.mcpServers && Object.keys(settings.mcpServers).length > 0) {
+      mcpServers = settings.mcpServers;
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    errors.push(`Failed to parse Roo configuration: ${errorMessage}`);
+    errors.push(`Failed to parse settings.json: ${errorMessage}`);
+  }
+  return {
+    errors,
+    ...mcpServers && { mcpServers }
+  };
+}
+async function parseAiexclude(aiexcludePath) {
+  try {
+    const content = await readFileContent(aiexcludePath);
+    const patterns = content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    return patterns;
+  } catch (_error) {
+    return [];
+  }
+}
+
+// src/parsers/roo.ts
+var import_node_path19 = require("path");
+async function parseRooConfiguration(baseDir = process.cwd()) {
+  const errors = [];
+  const rules = [];
+  const rooFilePath = (0, import_node_path19.join)(baseDir, ".roo", "instructions.md");
+  if (await fileExists(rooFilePath)) {
+    try {
+      const content = await readFileContent(rooFilePath);
+      if (content.trim()) {
+        const frontmatter = {
+          root: false,
+          targets: ["roo"],
+          description: "Roo Code instructions",
+          globs: ["**/*"]
+        };
+        rules.push({
+          frontmatter,
+          content: content.trim(),
+          filename: "roo-instructions",
+          filepath: rooFilePath
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .roo/instructions.md: ${errorMessage}`);
+    }
+  }
+  const rooRulesDir = (0, import_node_path19.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_path19.join)(rooRulesDir, file);
+          try {
+            const content = await readFileContent(filePath);
+            if (content.trim()) {
+              const filename = file.replace(".md", "");
+              const frontmatter = {
+                root: false,
+                targets: ["roo"],
+                description: `Roo rule: ${filename}`,
+                globs: ["**/*"]
+              };
+              rules.push({
+                frontmatter,
+                content: content.trim(),
+                filename: `roo-${filename}`,
+                filepath: filePath
+              });
+            }
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to parse ${filePath}: ${errorMessage}`);
+          }
+        }
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to parse .roo/rules files: ${errorMessage}`);
+    }
+  }
+  if (rules.length === 0) {
+    errors.push("No Roo Code configuration files found (.roo/instructions.md or .roo/rules/*.md)");
   }
   return { rules, errors };
 }
@@ -1036,6 +2005,8 @@ async function importConfiguration(options) {
   const { tool, baseDir = process.cwd(), rulesDir = ".rulesync", verbose = false } = options;
   const errors = [];
   let rules = [];
+  let ignorePatterns;
+  let mcpServers;
   if (verbose) {
     console.log(`Importing ${tool} configuration from ${baseDir}...`);
   }
@@ -1045,12 +2016,16 @@ async function importConfiguration(options) {
         const claudeResult = await parseClaudeConfiguration(baseDir);
         rules = claudeResult.rules;
         errors.push(...claudeResult.errors);
+        ignorePatterns = claudeResult.ignorePatterns;
+        mcpServers = claudeResult.mcpServers;
         break;
       }
       case "cursor": {
         const cursorResult = await parseCursorConfiguration(baseDir);
         rules = cursorResult.rules;
         errors.push(...cursorResult.errors);
+        ignorePatterns = cursorResult.ignorePatterns;
+        mcpServers = cursorResult.mcpServers;
         break;
       }
       case "copilot": {
@@ -1071,6 +2046,14 @@ async function importConfiguration(options) {
         errors.push(...rooResult.errors);
         break;
       }
+      case "geminicli": {
+        const geminiResult = await parseGeminiConfiguration(baseDir);
+        rules = geminiResult.rules;
+        errors.push(...geminiResult.errors);
+        ignorePatterns = geminiResult.ignorePatterns;
+        mcpServers = geminiResult.mcpServers;
+        break;
+      }
       default:
         errors.push(`Unsupported tool: ${tool}`);
         return { success: false, rulesCreated: 0, errors };
@@ -1080,10 +2063,10 @@ async function importConfiguration(options) {
     errors.push(`Failed to parse ${tool} configuration: ${errorMessage}`);
     return { success: false, rulesCreated: 0, errors };
   }
-  if (rules.length === 0) {
+  if (rules.length === 0 && !ignorePatterns && !mcpServers) {
     return { success: false, rulesCreated: 0, errors };
   }
-  const rulesDirPath = (0, import_node_path16.join)(baseDir, rulesDir);
+  const rulesDirPath = (0, import_node_path20.join)(baseDir, rulesDir);
   try {
     const { mkdir: mkdir3 } = await import("fs/promises");
     await mkdir3(rulesDirPath, { recursive: true });
@@ -1097,7 +2080,7 @@ async function importConfiguration(options) {
     try {
       const baseFilename = `${tool}__${rule.filename}`;
       const filename = await generateUniqueFilename(rulesDirPath, baseFilename);
-      const filePath = (0, import_node_path16.join)(rulesDirPath, `${filename}.md`);
+      const filePath = (0, import_node_path20.join)(rulesDirPath, `${filename}.md`);
       const content = generateRuleFileContent(rule);
       await writeFileContent(filePath, content);
       rulesCreated++;
@@ -1109,10 +2092,44 @@ async function importConfiguration(options) {
       errors.push(`Failed to create rule file for ${rule.filename}: ${errorMessage}`);
     }
   }
+  let ignoreFileCreated = false;
+  if (ignorePatterns && ignorePatterns.length > 0) {
+    try {
+      const rulesyncignorePath = (0, import_node_path20.join)(baseDir, ".rulesyncignore");
+      const ignoreContent = `${ignorePatterns.join("\n")}
+`;
+      await writeFileContent(rulesyncignorePath, ignoreContent);
+      ignoreFileCreated = true;
+      if (verbose) {
+        console.log(`\u2705 Created .rulesyncignore with ${ignorePatterns.length} patterns`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to create .rulesyncignore: ${errorMessage}`);
+    }
+  }
+  let mcpFileCreated = false;
+  if (mcpServers && Object.keys(mcpServers).length > 0) {
+    try {
+      const mcpPath = (0, import_node_path20.join)(baseDir, rulesDir, ".mcp.json");
+      const mcpContent = `${JSON.stringify({ mcpServers }, null, 2)}
+`;
+      await writeFileContent(mcpPath, mcpContent);
+      mcpFileCreated = true;
+      if (verbose) {
+        console.log(`\u2705 Created .mcp.json with ${Object.keys(mcpServers).length} servers`);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      errors.push(`Failed to create .mcp.json: ${errorMessage}`);
+    }
+  }
   return {
-    success: rulesCreated > 0,
+    success: rulesCreated > 0 || ignoreFileCreated || mcpFileCreated,
     rulesCreated,
-    errors
+    errors,
+    ignoreFileCreated,
+    mcpFileCreated
   };
 }
 function generateRuleFileContent(rule) {
@@ -1122,7 +2139,7 @@ function generateRuleFileContent(rule) {
 async function generateUniqueFilename(rulesDir, baseFilename) {
   let filename = baseFilename;
   let counter = 1;
-  while (await fileExists((0, import_node_path16.join)(rulesDir, `${filename}.md`))) {
+  while (await fileExists((0, import_node_path20.join)(rulesDir, `${filename}.md`))) {
     filename = `${baseFilename}-${counter}`;
     counter++;
   }
@@ -1140,57 +2157,54 @@ async function importCommand(options = {}) {
   if (options.geminicli) tools.push("geminicli");
   if (tools.length === 0) {
     console.error(
-      "\u274C Please specify at least one tool to import from (--claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
+      "\u274C Please specify one tool to import from (--claudecode, --cursor, --copilot, --cline, --roo, --geminicli)"
     );
     process.exit(1);
   }
-  console.log("Importing configuration files...");
-  let totalRulesCreated = 0;
-  const allErrors = [];
-  for (const tool of tools) {
-    if (options.verbose) {
-      console.log(`
-Importing from ${tool}...`);
-    }
-    try {
-      const result = await importConfiguration({
-        tool,
-        verbose: options.verbose ?? false
-      });
-      if (result.success) {
-        console.log(`\u2705 Imported ${result.rulesCreated} rule(s) from ${tool}`);
-        totalRulesCreated += result.rulesCreated;
-      } else if (result.errors.length > 0) {
-        console.warn(`\u26A0\uFE0F  Failed to import from ${tool}: ${result.errors[0]}`);
-        if (options.verbose) {
-          allErrors.push(...result.errors);
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error(`\u274C Error importing from ${tool}: ${errorMessage}`);
-      allErrors.push(`${tool}: ${errorMessage}`);
-    }
-  }
-  if (totalRulesCreated > 0) {
-    console.log(`
-\u{1F389} Successfully imported ${totalRulesCreated} rule(s) total!`);
-    console.log("You can now run 'rulesync generate' to create tool-specific configurations.");
-  } else {
-    console.warn(
-      "\n\u26A0\uFE0F  No rules were imported. Please check that configuration files exist for the selected tools."
+  if (tools.length > 1) {
+    console.error(
+      "\u274C Only one tool can be specified at a time. Please run the import command separately for each tool."
     );
+    process.exit(1);
   }
-  if (options.verbose && allErrors.length > 0) {
-    console.log("\nDetailed errors:");
-    for (const error of allErrors) {
-      console.log(`  - ${error}`);
+  const tool = tools[0];
+  if (!tool) {
+    console.error("Error: No tool specified");
+    process.exit(1);
+  }
+  console.log(`Importing configuration files from ${tool}...`);
+  try {
+    const result = await importConfiguration({
+      tool,
+      verbose: options.verbose ?? false
+    });
+    if (result.success) {
+      console.log(`\u2705 Imported ${result.rulesCreated} rule(s) from ${tool}`);
+      if (result.ignoreFileCreated) {
+        console.log("\u2705 Created .rulesyncignore file from ignore patterns");
+      }
+      if (result.mcpFileCreated) {
+        console.log("\u2705 Created .rulesync/.mcp.json file from MCP configuration");
+      }
+      console.log("You can now run 'rulesync generate' to create tool-specific configurations.");
+    } else if (result.errors.length > 0) {
+      console.warn(`\u26A0\uFE0F  Failed to import from ${tool}: ${result.errors[0]}`);
+      if (options.verbose && result.errors.length > 1) {
+        console.log("\nDetailed errors:");
+        for (const error of result.errors) {
+          console.log(`  - ${error}`);
+        }
+      }
     }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C Error importing from ${tool}: ${errorMessage}`);
+    process.exit(1);
   }
 }
 
 // src/cli/commands/init.ts
-var import_node_path17 = require("path");
+var import_node_path21 = require("path");
 async function initCommand() {
   const aiRulesDir = ".rulesync";
   console.log("Initializing rulesync...");
@@ -1320,7 +2334,7 @@ globs: ["src/api/**/*.ts", "src/services/**/*.ts", "src/models/**/*.ts"]
     }
   ];
   for (const file of sampleFiles) {
-    const filepath = (0, import_node_path17.join)(aiRulesDir, file.filename);
+    const filepath = (0, import_node_path21.join)(aiRulesDir, file.filename);
     if (!await fileExists(filepath)) {
       await writeFileContent(filepath, file.content);
       console.log(`Created ${filepath}`);
@@ -1433,11 +2447,11 @@ async function watchCommand() {
     persistent: true
   });
   let isGenerating = false;
-  const handleChange = async (path2) => {
+  const handleChange = async (path4) => {
     if (isGenerating) return;
     isGenerating = true;
     console.log(`
-\u{1F4DD} Detected change in ${path2}`);
+\u{1F4DD} Detected change in ${path4}`);
     try {
       await generateCommand({ verbose: false });
       console.log("\u2705 Regenerated configuration files");
@@ -1447,10 +2461,10 @@ async function watchCommand() {
       isGenerating = false;
     }
   };
-  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path2) => {
+  watcher.on("change", handleChange).on("add", handleChange).on("unlink", (path4) => {
     console.log(`
-\u{1F5D1}\uFE0F  Removed ${path2}`);
-    handleChange(path2);
+\u{1F5D1}\uFE0F  Removed ${path4}`);
+    handleChange(path4);
   }).on("error", (error) => {
     console.error("\u274C Watcher error:", error);
   });
@@ -1463,7 +2477,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.34.0");
+program.name("rulesync").description("Unified AI rules management CLI tool").version("0.36.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);