rulesync 0.65.0 → 0.68.1

package/dist/chunk-JXOLLTNV.js

@@ -1,392 +0,0 @@
-import {
-  shouldIncludeServer
-} from "./chunk-M2AUM37M.js";
-
-// src/constants/schemas.ts
-var SCHEMA_URLS = {
-  OPENCODE: "https://opencode.ai/config.json"
-};
-
-// src/generators/mcp/shared-factory.ts
-function generateMcpConfig(config, toolConfig) {
-  const servers = {};
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldIncludeServer(server, toolConfig.target)) continue;
-    servers[serverName] = toolConfig.serverTransform(server, serverName);
-  }
-  const finalConfig = toolConfig.configWrapper(servers);
-  return JSON.stringify(finalConfig, null, 2);
-}
-function generateMcpConfigurationFiles(mcpServers, toolConfig, baseDir = "") {
-  const configs = [];
-  const rulesyncConfig = { mcpServers };
-  for (const configPath of toolConfig.configPaths) {
-    const filepath = baseDir ? `${baseDir}/${configPath}` : configPath;
-    const content = generateMcpConfig(rulesyncConfig, toolConfig);
-    configs.push({
-      filepath,
-      content: `${content}
-`
-    });
-  }
-  return configs;
-}
-var serverTransforms = {
-  /**
-   * Basic server transformation (command, args, env, url handling)
-   */
-  basic: (server) => {
-    const result = {};
-    if (server.command) {
-      result.command = server.command;
-      if (server.args) result.args = server.args;
-    }
-    if (server.url || server.httpUrl) {
-      const url = server.httpUrl || server.url;
-      if (url) result.url = url;
-    }
-    if (server.env) {
-      result.env = server.env;
-    }
-    return result;
-  },
-  /**
-   * Roo-specific server transformation (preserves httpUrl, transport, type, etc.)
-   */
-  roo: (server) => {
-    const result = serverTransforms.extended(server);
-    if (server.httpUrl) {
-      if (!server.url) {
-        result.httpUrl = server.httpUrl;
-        delete result.url;
-      }
-    }
-    if (server.transport) {
-      result.transport = server.transport;
-    }
-    if (server.type) {
-      result.type = server.type;
-    }
-    return result;
-  },
-  /**
-   * Extended server transformation (includes disabled, alwaysAllow, etc.)
-   */
-  extended: (server) => {
-    const result = serverTransforms.basic(server);
-    if (server.disabled !== void 0) {
-      result.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      result.alwaysAllow = server.alwaysAllow;
-    }
-    if (server.networkTimeout !== void 0) {
-      result.networkTimeout = server.networkTimeout;
-    }
-    if (server.tools) {
-      result.tools = server.tools;
-    }
-    if (server.timeout !== void 0) {
-      result.timeout = server.timeout;
-    }
-    if (server.trust !== void 0) {
-      result.trust = server.trust;
-    }
-    if (server.headers) {
-      result.headers = server.headers;
-    }
-    return result;
-  },
-  /**
-   * Remove rulesync-specific properties from server config
-   */
-  cleanRulesyncProps: (server) => {
-    const { targets: _, transport: _transport, ...cleanServer } = server;
-    return { ...cleanServer };
-  }
-};
-var configWrappers = {
-  /**
-   * Standard mcpServers wrapper
-   */
-  mcpServers: (servers) => ({
-    mcpServers: servers
-  }),
-  /**
-   * Servers-only wrapper (for tools that use "servers" instead of "mcpServers")
-   */
-  servers: (servers) => ({
-    servers
-  })
-};
-var MCP_GENERATOR_REGISTRY = {
-  roo: {
-    target: "roo",
-    configPaths: [".roo/mcp.json"],
-    serverTransform: serverTransforms.roo,
-    configWrapper: configWrappers.mcpServers
-  },
-  claudecode: {
-    target: "claudecode",
-    configPaths: [".mcp.json"],
-    serverTransform: (server) => {
-      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;
-      }
-      return claudeServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  },
-  cursor: {
-    target: "cursor",
-    configPaths: [".cursor/mcp.json"],
-    serverTransform: (server) => {
-      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;
-      }
-      return cursorServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  },
-  windsurf: {
-    target: "windsurf",
-    configPaths: ["mcp_config.json"],
-    serverTransform: (server) => {
-      const windsurfServer = {};
-      if (server.command) {
-        windsurfServer.command = server.command;
-        if (server.args) windsurfServer.args = server.args;
-      } else if (server.url || server.httpUrl) {
-        const url = server.httpUrl || server.url;
-        if (url) {
-          windsurfServer.serverUrl = url;
-        }
-      }
-      if (server.env) {
-        windsurfServer.env = server.env;
-      }
-      if (server.cwd) {
-        windsurfServer.cwd = server.cwd;
-      }
-      return windsurfServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  },
-  junie: {
-    target: "junie",
-    configPaths: [".junie/mcp/mcp.json"],
-    serverTransform: (server, serverName) => {
-      const junieServer = {
-        name: serverName
-      };
-      if (server.command) {
-        junieServer.command = server.command;
-        if (server.args) junieServer.args = server.args;
-      } else if (server.url || server.httpUrl) {
-        if (server.httpUrl) {
-          junieServer.httpUrl = server.httpUrl;
-        } else if (server.url) {
-          junieServer.url = server.url;
-        }
-      }
-      if (server.env) {
-        junieServer.env = server.env;
-      }
-      if (server.cwd) {
-        junieServer.workingDirectory = server.cwd;
-      }
-      if (server.timeout !== void 0) {
-        junieServer.timeout = server.timeout;
-      }
-      if (server.trust !== void 0) {
-        junieServer.trust = server.trust;
-      }
-      if (server.transport) {
-        if (String(server.transport) === "streamable-http") {
-          junieServer.transport = "http";
-        } else if (server.transport === "stdio" || server.transport === "http" || server.transport === "sse") {
-          junieServer.transport = server.transport;
-        }
-      } else if (server.command) {
-        junieServer.transport = "stdio";
-      }
-      return junieServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  },
-  cline: {
-    target: "cline",
-    configPaths: [".cline/mcp.json"],
-    serverTransform: serverTransforms.extended,
-    configWrapper: configWrappers.mcpServers
-  },
-  geminicli: {
-    target: "geminicli",
-    configPaths: [".gemini/settings.json"],
-    serverTransform: (server) => {
-      const { targets: _, ...serverConfig } = server;
-      const geminiServer = { ...serverConfig };
-      if (server.env) {
-        geminiServer.env = server.env;
-      }
-      return geminiServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  },
-  opencode: {
-    target: "opencode",
-    configPaths: ["opencode.json"],
-    serverTransform: (server) => {
-      const opencodeServer = {};
-      if (server.command) {
-        opencodeServer.type = "local";
-        opencodeServer.command = Array.isArray(server.command) ? server.command : [server.command];
-        if (server.args) opencodeServer.args = server.args;
-        if (server.env) opencodeServer.environment = server.env;
-        if (server.cwd) opencodeServer.cwd = server.cwd;
-      } else if (server.url || server.httpUrl) {
-        opencodeServer.type = "remote";
-        const url = server.httpUrl || server.url;
-        if (url) opencodeServer.url = url;
-        if (server.headers) opencodeServer.headers = server.headers;
-      }
-      if (server.disabled !== void 0) {
-        opencodeServer.enabled = !server.disabled;
-      } else {
-        opencodeServer.enabled = true;
-      }
-      return opencodeServer;
-    },
-    configWrapper: (servers) => ({
-      $schema: SCHEMA_URLS.OPENCODE,
-      mcp: servers
-    })
-  },
-  qwencode: {
-    target: "qwencode",
-    configPaths: [".qwen/settings.json"],
-    serverTransform: (server) => {
-      const { targets: _, ...serverConfig } = server;
-      const qwenServer = { ...serverConfig };
-      if (server.env) {
-        qwenServer.env = server.env;
-      }
-      return qwenServer;
-    },
-    configWrapper: configWrappers.mcpServers
-  }
-};
-function generateMcpFromRegistry(tool, config) {
-  const generatorConfig = MCP_GENERATOR_REGISTRY[tool];
-  if (!generatorConfig) {
-    throw new Error(`No MCP generator configuration found for tool: ${tool}`);
-  }
-  return generateMcpConfig(config, generatorConfig);
-}
-function createMcpGenerator(toolName) {
-  return {
-    generateMcp: (config) => {
-      return generateMcpFromRegistry(toolName, config);
-    },
-    generateMcpConfiguration: (mcpServers, baseDir = "") => {
-      return generateMcpConfigurationFilesFromRegistry(toolName, mcpServers, baseDir);
-    }
-  };
-}
-var cursorMcpGenerator = createMcpGenerator("cursor");
-var clineMcpGenerator = createMcpGenerator("cline");
-function generateMcpConfigurationFilesFromRegistry(tool, mcpServers, baseDir = "") {
-  const generatorConfig = MCP_GENERATOR_REGISTRY[tool];
-  if (!generatorConfig) {
-    throw new Error(`No MCP generator configuration found for tool: ${tool}`);
-  }
-  if (tool === "junie") {
-    return generateJunieMcpConfigurationFiles(mcpServers, baseDir);
-  }
-  const customTools = ["copilot", "augmentcode", "codexcli", "kiro"];
-  if (customTools.includes(tool)) {
-    throw new Error(
-      `Tool ${tool} uses custom configuration logic - use its specific generator function instead`
-    );
-  }
-  return generateMcpConfigurationFiles(mcpServers, generatorConfig, baseDir);
-}
-function generateJunieMcpConfigurationFiles(mcpServers, baseDir = "") {
-  const junieMcpPath = ".junie/mcp/mcp.json";
-  const filepath = baseDir ? `${baseDir}/${junieMcpPath}` : junieMcpPath;
-  const config = {
-    mcpServers: {}
-  };
-  for (const [serverName, server] of Object.entries(mcpServers)) {
-    if (!shouldIncludeServer(server, "junie")) {
-      continue;
-    }
-    const { targets: _, transport, cwd, ...serverConfig } = server;
-    const junieServer = {
-      ...serverConfig,
-      name: serverName
-    };
-    if (cwd) {
-      junieServer.workingDirectory = cwd;
-    }
-    if (transport) {
-      if (String(transport) === "streamable-http") {
-        junieServer.transport = "http";
-      } else if (transport === "stdio" || transport === "http" || transport === "sse") {
-        junieServer.transport = transport;
-      }
-    } else if (serverConfig.command) {
-      junieServer.transport = "stdio";
-    }
-    config.mcpServers[serverName] = junieServer;
-  }
-  return [
-    {
-      filepath,
-      content: `${JSON.stringify(config, null, 2)}
-`
-    }
-  ];
-}
-
-export {
-  generateMcpConfig,
-  generateMcpConfigurationFiles,
-  generateMcpFromRegistry,
-  cursorMcpGenerator,
-  clineMcpGenerator,
-  generateMcpConfigurationFilesFromRegistry
-};

package/dist/chunk-LTWEI4PW.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/windsurf.ts
-function generateWindsurfMcp(config) {
-  return generateMcpFromRegistry("windsurf", config);
-}
-function generateWindsurfMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFilesFromRegistry("windsurf", mcpServers, baseDir);
-}
-
-export {
-  generateWindsurfMcp,
-  generateWindsurfMcpConfiguration
-};

package/dist/chunk-M2AUM37M.js

@@ -1,54 +0,0 @@
-// src/types/tool-targets.ts
-import { z } from "zod/mini";
-var ALL_TOOL_TARGETS = [
-  "amazonqcli",
-  "augmentcode",
-  "augmentcode-legacy",
-  "copilot",
-  "cursor",
-  "cline",
-  "claudecode",
-  "codexcli",
-  "opencode",
-  "qwencode",
-  "roo",
-  "geminicli",
-  "kiro",
-  "junie",
-  "windsurf"
-];
-var ToolTargetSchema = z.enum(ALL_TOOL_TARGETS);
-var ToolTargetsSchema = z.array(ToolTargetSchema);
-var WildcardTargetSchema = z.tuple([z.literal("*")]);
-var RulesyncTargetsSchema = z.union([ToolTargetsSchema, WildcardTargetSchema]);
-function isToolTarget(target) {
-  if (!target) return false;
-  return ALL_TOOL_TARGETS.some((validTarget) => validTarget === target);
-}
-
-// src/utils/mcp-helpers.ts
-function shouldIncludeServer(server, targetTool) {
-  if (!server.targets || server.targets.length === 0) {
-    return true;
-  }
-  const parsedTargets = RulesyncTargetsSchema.parse(server.targets);
-  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 {
-  ALL_TOOL_TARGETS,
-  ToolTargetSchema,
-  ToolTargetsSchema,
-  RulesyncTargetsSchema,
-  isToolTarget,
-  shouldIncludeServer
-};

package/dist/chunk-N6DASHJL.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/junie.ts
-function generateJunieMcp(config) {
-  return generateMcpFromRegistry("junie", config);
-}
-function generateJunieMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFilesFromRegistry("junie", mcpServers, baseDir);
-}
-
-export {
-  generateJunieMcp,
-  generateJunieMcpConfiguration
-};

package/dist/chunk-TX2CE4RR.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/qwencode.ts
-function generateQwenCodeMcp(config) {
-  return generateMcpFromRegistry("qwencode", config);
-}
-function generateQwenCodeMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFilesFromRegistry("qwencode", mcpServers, baseDir);
-}
-
-export {
-  generateQwenCodeMcp,
-  generateQwenCodeMcpConfiguration
-};

package/dist/chunk-UGY5ALND.js

@@ -1,145 +0,0 @@
-import {
-  generateMcpConfig,
-  generateMcpConfigurationFiles
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/codexcli.ts
-function generateCodexMcp(config) {
-  return generateMcpConfig(config, {
-    target: "codexcli",
-    configPaths: [".codex/mcp-config.json"],
-    serverTransform: (server) => {
-      const codexServer = {};
-      if (server.command) {
-        codexServer.command = server.command;
-        if (server.args) codexServer.args = server.args;
-        codexServer.transport = server.transport || "stdio";
-      } else if (server.url || server.httpUrl) {
-        const url = server.httpUrl || server.url;
-        if (url) {
-          codexServer.url = url;
-        }
-        if (server.httpUrl) {
-          codexServer.transport = "http";
-        } else if (server.transport === "sse") {
-          codexServer.transport = "sse";
-        } else if (server.transport === "http") {
-          codexServer.transport = "http";
-        } else {
-          codexServer.transport = "stdio";
-        }
-      } else {
-        codexServer.transport = "stdio";
-      }
-      if (server.env) {
-        codexServer.env = { ...server.env };
-        if (!codexServer.env.CODEX_DEFAULT_MODEL) {
-          codexServer.env.CODEX_DEFAULT_MODEL = "gpt-4o-mini";
-        }
-      }
-      if (server.cwd) {
-        codexServer.cwd = server.cwd;
-        codexServer.workingDirectory = server.cwd;
-      }
-      if (server.timeout) {
-        codexServer.timeout = server.timeout;
-      }
-      if (server.headers) {
-        codexServer.headers = server.headers;
-      }
-      return codexServer;
-    },
-    configWrapper: (servers) => ({
-      // Configuration format for MCP wrapper servers that expose Codex CLI functionality
-      servers,
-      _comment: "Configuration for MCP wrapper servers like openai-codex-mcp that integrate with Codex CLI",
-      _usage: "This file is intended for use with third-party MCP servers that wrap Codex CLI functionality",
-      _examples: {
-        python_server: "python -m mcp_server or uvicorn codex_server:app",
-        nodejs_server: "node dist/server.js or npm start",
-        docker_server: "docker run -i --rm custom/codex-mcp:latest"
-      },
-      _security_note: "Store API keys in environment variables, not in this configuration file"
-    })
-  });
-}
-function generateCodexMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFiles(
-    mcpServers,
-    {
-      target: "codexcli",
-      configPaths: [".codex/mcp-config.json"],
-      serverTransform: (server) => {
-        const { targets: _, transport, ...serverConfig } = server;
-        const codexServer = {};
-        if (serverConfig.command !== void 0) codexServer.command = serverConfig.command;
-        if (serverConfig.args !== void 0) codexServer.args = serverConfig.args;
-        if (serverConfig.url !== void 0) codexServer.url = serverConfig.url;
-        if (serverConfig.httpUrl !== void 0) codexServer.httpUrl = serverConfig.httpUrl;
-        if (serverConfig.env !== void 0) codexServer.env = serverConfig.env;
-        if (serverConfig.disabled !== void 0) codexServer.disabled = serverConfig.disabled;
-        if (serverConfig.networkTimeout !== void 0)
-          codexServer.networkTimeout = serverConfig.networkTimeout;
-        if (serverConfig.timeout !== void 0) codexServer.timeout = serverConfig.timeout;
-        if (serverConfig.trust !== void 0) codexServer.trust = serverConfig.trust;
-        if (serverConfig.cwd !== void 0) codexServer.cwd = serverConfig.cwd;
-        if (serverConfig.type !== void 0) codexServer.type = serverConfig.type;
-        if (serverConfig.alwaysAllow !== void 0)
-          codexServer.alwaysAllow = serverConfig.alwaysAllow;
-        if (serverConfig.tools !== void 0) codexServer.tools = serverConfig.tools;
-        if (serverConfig.kiroAutoApprove !== void 0)
-          codexServer.autoApprove = serverConfig.kiroAutoApprove;
-        if (serverConfig.kiroAutoBlock !== void 0)
-          codexServer.autoBlock = serverConfig.kiroAutoBlock;
-        if (serverConfig.headers !== void 0) codexServer.headers = serverConfig.headers;
-        if (serverConfig.httpUrl !== void 0) {
-          codexServer.url = serverConfig.httpUrl;
-          delete codexServer.httpUrl;
-        }
-        if (transport) {
-          codexServer.transport = transport;
-        } else if (serverConfig.url && !serverConfig.httpUrl) {
-          codexServer.transport = "sse";
-        } else {
-          codexServer.transport = "stdio";
-        }
-        if (serverConfig.env) {
-          codexServer.env = { ...serverConfig.env };
-          if (!codexServer.env.CODEX_DEFAULT_MODEL) {
-            codexServer.env.CODEX_DEFAULT_MODEL = "gpt-4o-mini";
-          }
-        }
-        if (serverConfig.cwd) {
-          codexServer.cwd = serverConfig.cwd;
-          codexServer.workingDirectory = serverConfig.cwd;
-        }
-        if (serverConfig.timeout) {
-          codexServer.timeout = serverConfig.timeout;
-        }
-        if (serverConfig.headers) {
-          codexServer.headers = serverConfig.headers;
-        }
-        return codexServer;
-      },
-      configWrapper: (servers) => ({
-        // Configuration format for MCP wrapper servers that integrate with Codex CLI
-        servers,
-        _comment: "Configuration for MCP wrapper servers like openai-codex-mcp that integrate with Codex CLI",
-        _usage: "Use with third-party MCP servers that expose Codex CLI functionality to other MCP clients",
-        _examples: {
-          python_server: "python -m mcp_server or uvicorn codex_server:app",
-          nodejs_server: "node dist/server.js or npm start",
-          docker_server: "docker run -i --rm custom/codex-mcp:latest"
-        },
-        _security_note: "Store API keys in environment variables, not in this configuration file",
-        _supported_transports: ["stdio", "sse", "http"]
-      })
-    },
-    baseDir
-  );
-}
-
-export {
-  generateCodexMcp,
-  generateCodexMcpConfiguration
-};

package/dist/chunk-VRWNZTGW.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/roo.ts
-function generateRooMcp(config) {
-  return generateMcpFromRegistry("roo", config);
-}
-function generateRooMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFilesFromRegistry("roo", mcpServers, baseDir);
-}
-
-export {
-  generateRooMcp,
-  generateRooMcpConfiguration
-};

package/dist/chunk-YC2BC7Z2.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-JXOLLTNV.js";
-
-// src/generators/mcp/claudecode.ts
-function generateClaudeMcp(config) {
-  return generateMcpFromRegistry("claudecode", config);
-}
-function generateClaudeMcpConfiguration(mcpServers, baseDir = "") {
-  return generateMcpConfigurationFilesFromRegistry("claudecode", mcpServers, baseDir);
-}
-
-export {
-  generateClaudeMcp,
-  generateClaudeMcpConfiguration
-};

package/dist/claudecode-RZSJPPBU.js

@@ -1,10 +0,0 @@
-import {
-  generateClaudeMcp,
-  generateClaudeMcpConfiguration
-} from "./chunk-YC2BC7Z2.js";
-import "./chunk-JXOLLTNV.js";
-import "./chunk-M2AUM37M.js";
-export {
-  generateClaudeMcp,
-  generateClaudeMcpConfiguration
-};