rulesync 0.67.0 → 0.69.0

package/dist/chunk-V36ICGOY.js

@@ -1,392 +0,0 @@
-import {
-  shouldIncludeServer
-} from "./chunk-CS7AV6JT.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-WCON5BAI.js

@@ -1,12 +0,0 @@
-import {
-  cursorMcpGenerator
-} from "./chunk-V36ICGOY.js";
-
-// src/generators/mcp/cursor.ts
-var generateCursorMcp = cursorMcpGenerator.generateMcp;
-var generateCursorMcpConfiguration = cursorMcpGenerator.generateMcpConfiguration;
-
-export {
-  generateCursorMcp,
-  generateCursorMcpConfiguration
-};

package/dist/chunk-WFOWHPBC.js

@@ -1,210 +0,0 @@
-import {
-  shouldIncludeServer
-} from "./chunk-CS7AV6JT.js";
-
-// src/utils/file.ts
-import { mkdir, readdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { dirname, join, relative, resolve } from "path";
-
-// src/utils/logger.ts
-import { consola } from "consola";
-var Logger = class {
-  _verbose = false;
-  console = consola.withDefaults({
-    tag: "rulesync"
-  });
-  setVerbose(verbose) {
-    this._verbose = verbose;
-  }
-  get verbose() {
-    return this._verbose;
-  }
-  // Regular log (always shown, regardless of verbose)
-  log(message, ...args) {
-    this.console.log(message, ...args);
-  }
-  // Info level (shown only in verbose mode)
-  info(message, ...args) {
-    if (this._verbose) {
-      this.console.info(message, ...args);
-    }
-  }
-  // Success (always shown)
-  success(message, ...args) {
-    this.console.success(message, ...args);
-  }
-  // Warning (always shown)
-  warn(message, ...args) {
-    this.console.warn(message, ...args);
-  }
-  // Error (always shown)
-  error(message, ...args) {
-    this.console.error(message, ...args);
-  }
-  // Debug level (shown only in verbose mode)
-  debug(message, ...args) {
-    if (this._verbose) {
-      this.console.debug(message, ...args);
-    }
-  }
-};
-var logger = new Logger();
-
-// src/utils/file.ts
-async function ensureDir(dirPath) {
-  try {
-    await stat(dirPath);
-  } catch {
-    await mkdir(dirPath, { recursive: true });
-  }
-}
-function resolvePath(relativePath, baseDir) {
-  if (!baseDir) return relativePath;
-  const resolved = resolve(baseDir, relativePath);
-  const rel = relative(baseDir, resolved);
-  if (rel.startsWith("..") || resolve(resolved) !== resolved) {
-    throw new Error(`Path traversal detected: ${relativePath}`);
-  }
-  return resolved;
-}
-async function readFileContent(filepath) {
-  return readFile(filepath, "utf-8");
-}
-async function writeFileContent(filepath, content) {
-  await ensureDir(dirname(filepath));
-  await writeFile(filepath, content, "utf-8");
-}
-async function fileExists(filepath) {
-  try {
-    await stat(filepath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function findFiles(dir, extension = ".md") {
-  try {
-    const files = await readdir(dir);
-    return files.filter((file) => file.endsWith(extension)).map((file) => join(dir, file));
-  } catch {
-    return [];
-  }
-}
-async function findRuleFiles(aiRulesDir) {
-  const rulesDir = join(aiRulesDir, "rules");
-  const newLocationFiles = await findFiles(rulesDir, ".md");
-  const legacyLocationFiles = await findFiles(aiRulesDir, ".md");
-  const newLocationBasenames = new Set(
-    newLocationFiles.map((file) => file.split("/").pop()?.replace(/\.md$/, ""))
-  );
-  const filteredLegacyFiles = legacyLocationFiles.filter((file) => {
-    const basename = file.split("/").pop()?.replace(/\.md$/, "");
-    return !newLocationBasenames.has(basename);
-  });
-  return [...newLocationFiles, ...filteredLegacyFiles];
-}
-async function removeDirectory(dirPath) {
-  const dangerousPaths = [".", "/", "~", "src", "node_modules"];
-  if (dangerousPaths.includes(dirPath) || dirPath === "") {
-    logger.warn(`Skipping deletion of dangerous path: ${dirPath}`);
-    return;
-  }
-  try {
-    if (await fileExists(dirPath)) {
-      await rm(dirPath, { recursive: true, force: true });
-    }
-  } catch (error) {
-    logger.warn(`Failed to remove directory ${dirPath}:`, error);
-  }
-}
-async function removeFile(filepath) {
-  try {
-    if (await fileExists(filepath)) {
-      await rm(filepath);
-    }
-  } catch (error) {
-    logger.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/mcp/amazonqcli.ts
-async function generateAmazonqcliMcp(mcpServers, config, baseDir) {
-  const outputs = [];
-  const configPaths = [
-    ".amazonq/mcp.json"
-    // Workspace configuration
-    // Note: Global configuration is ~/.aws/amazonq/mcp.json but is user-specific
-    // According to precautions.md, we should not create user-level files
-  ];
-  for (const configPath of configPaths) {
-    const filepath = resolvePath(configPath, baseDir);
-    const content = generateAmazonqcliMcpConfig({ mcpServers });
-    outputs.push({
-      tool: "amazonqcli",
-      filepath,
-      content
-    });
-  }
-  return outputs;
-}
-function generateAmazonqcliMcpString(config) {
-  return generateAmazonqcliMcpConfig(config);
-}
-function generateAmazonqcliMcpConfig(config) {
-  const servers = {};
-  for (const [serverName, server] of Object.entries(config.mcpServers)) {
-    if (!shouldIncludeServer(server, "amazonqcli")) {
-      continue;
-    }
-    const amazonqServer = {};
-    if (server.command) {
-      amazonqServer.command = server.command;
-      if (server.args) {
-        amazonqServer.args = server.args;
-      }
-    }
-    if (server.env) {
-      amazonqServer.env = server.env;
-    }
-    if (server.timeout !== void 0) {
-      amazonqServer.timeout = server.timeout;
-    }
-    if (server.disabled !== void 0) {
-      amazonqServer.disabled = server.disabled;
-    }
-    if (server.alwaysAllow) {
-      amazonqServer.autoApprove = server.alwaysAllow;
-    }
-    servers[serverName] = amazonqServer;
-  }
-  const finalConfig = {
-    mcpServers: servers
-  };
-  return `${JSON.stringify(finalConfig, null, 2)}
-`;
-}
-
-export {
-  logger,
-  ensureDir,
-  resolvePath,
-  readFileContent,
-  writeFileContent,
-  fileExists,
-  findFiles,
-  findRuleFiles,
-  removeDirectory,
-  removeClaudeGeneratedFiles,
-  generateAmazonqcliMcp,
-  generateAmazonqcliMcpString
-};

package/dist/chunk-WYYQXVHC.js

@@ -1,17 +0,0 @@
-import {
-  generateMcpConfigurationFilesFromRegistry,
-  generateMcpFromRegistry
-} from "./chunk-V36ICGOY.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
-};