rulesync 0.34.0 → 0.37.0

package/README.ja.md

@@ -60,10 +60,7 @@ yarn global add rulesync
 
 1. **既存設定をインポート:**
    ```bash
-   # 複数のツールから一度にインポート
-   npx rulesync import --claudecode --cursor --copilot
-   
-   # または特定のツールからインポート
+   # 特定のツールからインポート（一度に1つのツールのみ指定可能）
    npx rulesync import --claudecode  # CLAUDE.mdと.claude/memories/*.mdから
    npx rulesync import --cursor      # .cursorrulesと.cursor/rules/*.mdcから
    npx rulesync import --copilot     # .github/copilot-instructions.mdから
@@ -226,8 +223,10 @@ npx rulesync import --cline      # .cline/instructions.mdからインポート
 npx rulesync import --roo        # .roo/instructions.mdからインポート
 npx rulesync import --geminicli  # GEMINI.mdと.gemini/memories/*.mdからインポート
 
-# 複数のツールからインポート
-npx rulesync import --claudecode --cursor --copilot
+# 各ツールを個別にインポート
+npx rulesync import --claudecode
+npx rulesync import --cursor
+npx rulesync import --copilot
 
 # インポート時の詳細出力
 npx rulesync import --claudecode --verbose
@@ -278,6 +277,33 @@ npx rulesync gitignore
 └── custom.md           # プロジェクト固有ルール (root: false)
 ```
 
+### .rulesyncignoreでファイルを除外
+
+プロジェクトルートに`.rulesyncignore`ファイルを作成することで、特定のルールファイルを処理から除外できます。このファイルはgitignoreスタイルのパターンを使用します。
+
+`.rulesyncignore`の例：
+```
+# テスト用ルールファイルを無視
+**/*.test.md
+
+# 一時ファイルを無視
+tmp/**/*
+
+# ドラフトルールを無視
+draft-*.md
+*-draft.md
+```
+
+`.rulesyncignore`が存在する場合、rulesyncは：
+1. 処理時にマッチするファイルをスキップ
+2. ツール固有のignoreファイルを生成：
+   - Cursor用の`.cursorignore`
+   - Cline用の`.clineignore`
+   - Roo Code用の`.rooignore`
+   - GitHub Copilot用の`.copilotignore`（コミュニティツール用）
+   - Gemini CLI用の`.aiexclude`
+   - Claude Code用に`.claude/settings.json`のpermissions.denyに`Read()`ルールを追加
+
 ### フロントマタースキーマ
 
 各ルールファイルには以下のフィールドを含むフロントマターが必要です：
@@ -348,6 +374,69 @@ npx rulesync validate
 - ファイルパターン（globs）が有効な構文を使用
 - ターゲットツールが認識される値である
 
+## MCP（Model Context Protocol）サポート
+
+rulesyncは、対応するAIツール用のMCPサーバー設定も管理できます。これにより、言語サーバーやその他のMCP互換サービスを一度設定すれば、複数のAIコーディングアシスタントにデプロイできます。
+
+### MCPをサポートするツール
+
+- **Claude Code** (`.mcp.json`)
+- **GitHub Copilot** (`.vscode/mcp.json`)
+- **Cursor** (`.cursor/mcp.json`)
+- **Cline** (`.cline/mcp.json`)
+- **Gemini CLI** (`.gemini/settings.json`)
+- **Roo Code** (`.roo/mcp.json`)
+
+### MCP設定
+
+プロジェクトに`.rulesync/.mcp.json`ファイルを作成：
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm",
+        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "ghcr.io/github/github-mcp-server"
+      ],
+      "env": {},
+      "rulesyncTargets": ["*"]
+    }
+  }
+}
+```
+
+### MCP設定フィールド
+
+- **`mcpServers`**: MCPサーバー設定を含むオブジェクト
+  - **`command`**: stdioベースのサーバー用の実行可能コマンド
+  - **`args`**: コマンド引数
+  - **`url`**: HTTP/SSEベースのサーバー用URL
+  - **`env`**: サーバーに渡す環境変数
+  - **`rulesyncTargets`**: このサーバーをデプロイするツール名の配列
+    - 特定のツール名を使用: `["claude", "cursor", "copilot"]`
+    - すべてのサポートツールにデプロイするには`["*"]`を使用
+    - 省略した場合、デフォルトですべてのツールにデプロイ
+
+### MCP設定の生成
+
+MCP設定はルールファイルと一緒に生成されます：
+
+```bash
+# ルールとMCP設定の両方を生成
+npx rulesync generate
+
+# 特定のツールのみ生成
+npx rulesync generate --claudecode --cursor
+
+# 特定のディレクトリに生成（monorepo）
+npx rulesync generate --base-dir ./packages/frontend
+```
+
+MCP設定は各ツールの適切な場所に生成され、ツールは起動時に自動的にそれらを読み込みます。
+
 ## ライセンス
 
 MIT License

package/README.md

@@ -60,10 +60,7 @@ If you already have AI tool configurations, you can import them into rulesync fo
 
 1. **Import existing configurations:**
    ```bash
-   # Import from multiple tools at once
-   npx rulesync import --claudecode --cursor --copilot
-   
-   # Or import from specific tools
+   # Import from specific tools (only one tool can be specified at a time)
    npx rulesync import --claudecode  # From CLAUDE.md and .claude/memories/*.md
    npx rulesync import --cursor      # From .cursorrules and .cursor/rules/*.mdc
    npx rulesync import --copilot     # From .github/copilot-instructions.md
@@ -226,8 +223,10 @@ npx rulesync import --cline      # Import from .cline/instructions.md
 npx rulesync import --roo        # Import from .roo/instructions.md
 npx rulesync import --geminicli  # Import from GEMINI.md and .gemini/memories/*.md
 
-# Import from multiple tools
-npx rulesync import --claudecode --cursor --copilot
+# Import each tool individually
+npx rulesync import --claudecode
+npx rulesync import --cursor
+npx rulesync import --copilot
 
 # Verbose output during import
 npx rulesync import --claudecode --verbose
@@ -278,6 +277,33 @@ npx rulesync gitignore
 └── custom.md           # Project-specific rules (root: false)
 ```
 
+### Excluding Files with .rulesyncignore
+
+You can exclude specific rule files from being processed by creating a `.rulesyncignore` file in your project root. This file uses gitignore-style patterns.
+
+Example `.rulesyncignore`:
+```
+# Ignore test rule files
+**/*.test.md
+
+# Ignore temporary files
+tmp/**/*
+
+# Ignore draft rules
+draft-*.md
+*-draft.md
+```
+
+When `.rulesyncignore` exists, rulesync will:
+1. Skip matching files during rule processing
+2. Generate tool-specific ignore files:
+   - `.cursorignore` for Cursor
+   - `.clineignore` for Cline
+   - `.rooignore` for Roo Code
+   - `.copilotignore` for GitHub Copilot (community tools)
+   - `.aiexclude` for Gemini CLI
+   - Update `.claude/settings.json` permissions.deny with `Read()` rules for Claude Code
+
 ### Frontmatter Schema
 
 Each rule file must include frontmatter with the following fields:
@@ -348,6 +374,69 @@ Common validation rules:
 - File patterns (globs) use valid syntax
 - Target tools are recognized values
 
+## MCP (Model Context Protocol) Support
+
+rulesync can also manage MCP server configurations for supported AI tools. This allows you to configure language servers and other MCP-compatible services once and deploy them across multiple AI coding assistants.
+
+### Supported MCP Tools
+
+- **Claude Code** (`.mcp.json`)
+- **GitHub Copilot** (`.vscode/mcp.json`)
+- **Cursor** (`.cursor/mcp.json`)
+- **Cline** (`.cline/mcp.json`)
+- **Gemini CLI** (`.gemini/settings.json`)
+- **Roo Code** (`.roo/mcp.json`)
+
+### MCP Configuration
+
+Create a `.rulesync/.mcp.json` file in your project:
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm",
+        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "ghcr.io/github/github-mcp-server"
+      ],
+      "env": {},
+      "rulesyncTargets": ["*"]
+    }
+  }
+}
+```
+
+### MCP Configuration Fields
+
+- **`mcpServers`**: Object containing MCP server configurations
+  - **`command`**: Executable command for stdio-based servers
+  - **`args`**: Command arguments
+  - **`url`**: URL for HTTP/SSE-based servers
+  - **`env`**: Environment variables to pass to the server
+  - **`rulesyncTargets`**: Array of tool names to deploy this server to
+    - Use specific tool names: `["claude", "cursor", "copilot"]`
+    - Use `["*"]` to deploy to all supported tools
+    - If omitted, server is deployed to all tools by default
+
+### Generating MCP Configurations
+
+MCP configurations are generated alongside rule files:
+
+```bash
+# Generate both rules and MCP configurations
+npx rulesync generate
+
+# Generate only for specific tools
+npx rulesync generate --claudecode --cursor
+
+# Generate in specific directories (monorepo)
+npx rulesync generate --base-dir ./packages/frontend
+```
+
+The MCP configurations will be generated in the appropriate locations for each tool, and the tools will automatically load them when started.
+
 ## License
 
 MIT License

package/dist/chunk-2BYTQ4LL.mjs

@@ -0,0 +1,67 @@
+import {
+  shouldIncludeServer
+} from "./chunk-QQN5GTOV.mjs";
+
+// src/generators/mcp/claude.ts
+function generateClaudeMcp(config, _target) {
+  const claudeSettings = {
+    mcpServers: {}
+  };
+  const shouldInclude = (server) => {
+    return shouldIncludeServer(server, "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);
+}
+function generateClaudeMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.claude/settings.json` : ".claude/settings.json";
+  const settings = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "claudecode")) {
+      continue;
+    }
+    const { rulesyncTargets: _, transport, ...serverConfig } = server;
+    const claudeServer = {
+      ...serverConfig
+    };
+    if (transport && transport !== "stdio") {
+      claudeServer.transport = transport;
+    }
+    settings.mcpServers[serverName] = claudeServer;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(settings, null, 2)}
+`
+    }
+  ];
+}
+
+export {
+  generateClaudeMcp,
+  generateClaudeMcpConfiguration
+};

package/dist/chunk-2CDVII2R.mjs

@@ -0,0 +1,62 @@
+import {
+  shouldIncludeServer
+} from "./chunk-QQN5GTOV.mjs";
+
+// src/generators/mcp/cline.ts
+function generateClineMcp(config, _target) {
+  const clineConfig = {
+    mcpServers: {}
+  };
+  const shouldInclude = (server) => {
+    return shouldIncludeServer(server, "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);
+}
+function generateClineMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.cline/mcp.json` : ".cline/mcp.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "cline")) {
+      continue;
+    }
+    const { rulesyncTargets: _, ...serverConfig } = server;
+    config.mcpServers[serverName] = serverConfig;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
+
+export {
+  generateClineMcp,
+  generateClineMcpConfiguration
+};

package/dist/chunk-3GVVX3G5.mjs

@@ -0,0 +1,78 @@
+import {
+  shouldIncludeServer
+} from "./chunk-QQN5GTOV.mjs";
+
+// src/generators/mcp/roo.ts
+function generateRooMcp(config, _target) {
+  const rooConfig = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "roo")) 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);
+}
+function generateRooMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.roo/mcp.json` : ".roo/mcp.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!server || typeof server !== "object") {
+      continue;
+    }
+    const serverObj = server;
+    if (!shouldIncludeServer(serverObj, "roo")) {
+      continue;
+    }
+    const { rulesyncTargets: _rulesyncTargets, ...serverConfig } = serverObj;
+    config.mcpServers[serverName] = serverConfig;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
+
+export {
+  generateRooMcp,
+  generateRooMcpConfiguration
+};

package/dist/chunk-KZATM2CQ.mjs

@@ -0,0 +1,65 @@
+import {
+  shouldIncludeServer
+} from "./chunk-QQN5GTOV.mjs";
+
+// src/generators/mcp/cursor.ts
+function generateCursorMcp(config, _target) {
+  const cursorConfig = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "cursor")) continue;
+    const cursorServer = {};
+    if (server.command) {
+      cursorServer.command = server.command;
+      if (server.args) cursorServer.args = server.args;
+    } else if (server.url || server.httpUrl) {
+      const url = server.httpUrl || server.url;
+      if (url) {
+        cursorServer.url = url;
+      }
+      if (server.httpUrl || server.transport === "http") {
+        cursorServer.type = "streamable-http";
+      } else if (server.transport === "sse" || server.type === "sse") {
+        cursorServer.type = "sse";
+      }
+    }
+    if (server.env) {
+      cursorServer.env = server.env;
+    }
+    if (server.cwd) {
+      cursorServer.cwd = server.cwd;
+    }
+    cursorConfig.mcpServers[serverName] = cursorServer;
+  }
+  return JSON.stringify(cursorConfig, null, 2);
+}
+function generateCursorMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.cursor/mcp.json` : ".cursor/mcp.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!server || typeof server !== "object") {
+      continue;
+    }
+    const serverObj = server;
+    if (!shouldIncludeServer(serverObj, "cursor")) {
+      continue;
+    }
+    const { rulesyncTargets: _rulesyncTargets, ...serverConfig } = serverObj;
+    config.mcpServers[serverName] = serverConfig;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
+
+export {
+  generateCursorMcp,
+  generateCursorMcpConfiguration
+};

package/dist/chunk-PBOKMNYU.mjs

@@ -0,0 +1,67 @@
+import {
+  shouldIncludeServer
+} from "./chunk-QQN5GTOV.mjs";
+
+// src/generators/mcp/geminicli.ts
+function generateGeminiCliMcp(config, _target) {
+  const geminiSettings = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(config.mcpServers)) {
+    if (!shouldIncludeServer(server, "geminicli")) continue;
+    const geminiServer = {};
+    if (server.command) {
+      geminiServer.command = server.command;
+      if (server.args) geminiServer.args = server.args;
+    } else if (server.url || server.httpUrl) {
+      if (server.httpUrl) {
+        geminiServer.httpUrl = server.httpUrl;
+      } else if (server.url) {
+        geminiServer.url = server.url;
+      }
+    }
+    if (server.env) {
+      geminiServer.env = {};
+      for (const [key, value] of Object.entries(server.env)) {
+        if (value.startsWith("${") && value.endsWith("}")) {
+          geminiServer.env[key] = value;
+        } else {
+          geminiServer.env[key] = `\${${value}}`;
+        }
+      }
+    }
+    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);
+}
+function generateGeminiCliMcpConfiguration(mcpServers, baseDir = "") {
+  const filepath = baseDir ? `${baseDir}/.gemini/settings.json` : ".gemini/settings.json";
+  const config = {
+    mcpServers: {}
+  };
+  for (const [serverName, server] of Object.entries(mcpServers)) {
+    if (!shouldIncludeServer(server, "geminicli")) {
+      continue;
+    }
+    const { rulesyncTargets: _, ...serverConfig } = server;
+    config.mcpServers[serverName] = serverConfig;
+  }
+  return [
+    {
+      filepath,
+      content: `${JSON.stringify(config, null, 2)}
+`
+    }
+  ];
+}
+
+export {
+  generateGeminiCliMcp,
+  generateGeminiCliMcpConfiguration
+};

package/dist/chunk-QQN5GTOV.mjs

@@ -0,0 +1,56 @@
+// src/schemas/mcp.ts
+import { z } from "zod";
+var ToolTargetSchema = z.enum([
+  "copilot",
+  "cursor",
+  "cline",
+  "claudecode",
+  "claude",
+  "roo",
+  "geminicli"
+]);
+var WildcardTargetSchema = z.tuple([z.literal("*")]);
+var SpecificTargetsSchema = z.array(ToolTargetSchema);
+var RulesyncTargetsSchema = z.union([SpecificTargetsSchema, WildcardTargetSchema]);
+var McpTransportTypeSchema = z.enum(["stdio", "sse", "http"]);
+var McpServerBaseSchema = z.object({
+  command: z.string().optional(),
+  args: z.array(z.string()).optional(),
+  url: z.string().optional(),
+  httpUrl: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  disabled: z.boolean().optional(),
+  networkTimeout: z.number().optional(),
+  timeout: z.number().optional(),
+  trust: z.boolean().optional(),
+  cwd: z.string().optional(),
+  transport: McpTransportTypeSchema.optional(),
+  type: z.enum(["sse", "streamable-http"]).optional(),
+  alwaysAllow: z.array(z.string()).optional(),
+  tools: z.array(z.string()).optional()
+});
+var RulesyncMcpServerSchema = McpServerBaseSchema.extend({
+  rulesyncTargets: RulesyncTargetsSchema.optional()
+});
+
+// src/utils/mcp-helpers.ts
+function shouldIncludeServer(server, targetTool) {
+  if (!server.rulesyncTargets || server.rulesyncTargets.length === 0) {
+    return true;
+  }
+  const parsedTargets = RulesyncTargetsSchema.parse(server.rulesyncTargets);
+  if (parsedTargets.length === 1 && parsedTargets[0] === "*") {
+    return true;
+  }
+  const validatedTool = ToolTargetSchema.parse(targetTool);
+  for (const target of parsedTargets) {
+    if (target === validatedTool) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  shouldIncludeServer
+};