@intellectronica/ruler 0.3.1 → 0.3.3

package/README.md

@@ -75,6 +75,7 @@ Ruler solves this by providing a **single source of truth** for all your AI agen
 | opencode         | `AGENTS.md`                                      | `opencode.json`                                  |
 | Goose            | `.goosehints`                                    | -                                                |
 | Qwen Code        | `AGENTS.md`                                      | `.qwen/settings.json`                            |
+| RooCode          | `AGENTS.md`                                      | `.roo/mcp.json`                                  |
 | Zed              | `AGENTS.md`                                      | `.zed/settings.json` (project root, never $HOME) |
 | Warp             | `WARP.md`                                        | -                                                |
 | Kiro             | `.kiro/steering/ruler_kiro_instructions.md`      | -                                                |
@@ -214,7 +215,7 @@ The `apply` command looks for `.ruler/` in the current directory tree, reading t
 | Option                         | Description                                                                                                                                                                     |
 | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `--project-root <path>`        | Path to your project's root (default: current directory)                                                                                                                        |
-| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to target (agentsmd, amp, copilot, claude, codex, cursor, windsurf, cline, aider, firebase, gemini-cli, junie, augmentcode, kilocode, warp) |
+| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to target (agentsmd, amp, copilot, claude, codex, cursor, windsurf, cline, aider, firebase, gemini-cli, junie, augmentcode, kilocode, warp, roo) |
 | `--config <path>`              | Path to a custom `ruler.toml` configuration file                                                                                                                                |
 | `--mcp` / `--with-mcp`         | Enable applying MCP server configurations (default: true)                                                                                                                       |
 | `--no-mcp`                     | Disable applying MCP server configurations                                                                                                                                      |
@@ -250,6 +251,12 @@ ruler apply --agents firebase
 ruler apply --agents warp
 ```
 
+**Apply rules only to RooCode:**
+
+```bash
+ruler apply --agents roo
+```
+
 **Use a specific configuration file:**
 
 ```bash

package/dist/agents/AbstractAgent.js

@@ -50,11 +50,13 @@ class AbstractAgent {
      * 4. Writing the new content
      */
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, concatenatedRules);
     }
     /**

package/dist/agents/AgentsMdAgent.js

@@ -54,7 +54,7 @@ class AgentsMdAgent extends AbstractAgent_1.AbstractAgent {
         return path.join(projectRoot, 'AGENTS.md');
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
@@ -72,8 +72,10 @@ class AgentsMdAgent extends AbstractAgent_1.AbstractAgent {
             // No change; skip backup/write for idempotency
             return;
         }
-        // Backup (only if file existed) then write new content
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        // Backup (only if file existed and backup is enabled) then write new content
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, contentWithMarker);
     }
     getMcpServerKey() {

package/dist/agents/AiderAgent.js

@@ -52,21 +52,23 @@ class AiderAgent {
     getName() {
         return 'Aider';
     }
-    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig) {
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
         // First perform idempotent AGENTS.md write via composed AgentsMdAgent
         await this.agentsMdAgent.applyRulerConfig(concatenatedRules, projectRoot, null, {
             // Preserve explicit outputPath precedence semantics if provided.
             outputPath: agentConfig?.outputPath ||
                 agentConfig?.outputPathInstructions ||
                 undefined,
-        });
+        }, backup);
         // Now handle .aider.conf.yml configuration
         const cfgPath = agentConfig?.outputPathConfig ??
             this.getDefaultOutputPath(projectRoot).config;
         let doc = {};
         try {
             await fs.access(cfgPath);
-            await (0, FileSystemUtils_1.backupFile)(cfgPath);
+            if (backup) {
+                await (0, FileSystemUtils_1.backupFile)(cfgPath);
+            }
             const raw = await fs.readFile(cfgPath, 'utf8');
             doc = (yaml.load(raw) || {});
         }

package/dist/agents/AugmentCodeAgent.js

@@ -48,9 +48,11 @@ class AugmentCodeAgent {
         return 'AugmentCode';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
-        await (0, FileSystemUtils_1.backupFile)(output);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(output);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(output, concatenatedRules);
         // AugmentCode does not support MCP servers
         // MCP configuration is ignored for this agent

package/dist/agents/CodexCliAgent.js

@@ -66,14 +66,21 @@ class CodexCliAgent extends AgentsMdAgent_1.AgentsMdAgent {
         };
         const mcpEnabled = agentConfig?.mcp?.enabled ?? true;
         if (mcpEnabled && rulerMcpJson) {
+            // Apply MCP server filtering and transformation
+            const { filterMcpConfigForAgent } = await Promise.resolve().then(() => __importStar(require('../mcp/capabilities')));
+            const filteredMcpConfig = filterMcpConfigForAgent(rulerMcpJson, this);
+            if (!filteredMcpConfig) {
+                return; // No compatible servers found
+            }
+            const filteredRulerMcpJson = filteredMcpConfig;
             // Determine the config file path
             const configPath = agentConfig?.outputPathConfig ?? defaults.config;
             // Ensure the parent directory exists
             await fs_1.promises.mkdir(path.dirname(configPath), { recursive: true });
             // Get the merge strategy
             const strategy = agentConfig?.mcp?.strategy ?? 'merge';
-            // Extract MCP servers from ruler config
-            const rulerServers = rulerMcpJson.mcpServers || {};
+            // Extract MCP servers from filtered ruler config
+            const rulerServers = filteredRulerMcpJson.mcpServers || {};
             // Read existing TOML config if it exists
             let existingConfig = {};
             try {
@@ -106,6 +113,10 @@ class CodexCliAgent extends AgentsMdAgent_1.AgentsMdAgent {
                 if (serverConfig.env) {
                     mcpServer.env = serverConfig.env;
                 }
+                // Handle additional properties from remote server transformation
+                if (serverConfig.headers) {
+                    mcpServer.headers = serverConfig.headers;
+                }
                 if (updatedConfig.mcp_servers) {
                     updatedConfig.mcp_servers[serverName] = mcpServer;
                 }
@@ -147,6 +158,20 @@ class CodexCliAgent extends AgentsMdAgent_1.AgentsMdAgent {
                         }
                         tomlContent += ` }\n`;
                     }
+                    // Add headers as inline table if present (from transformed remote servers)
+                    if (serverConfig.headers &&
+                        Object.keys(serverConfig.headers).length > 0) {
+                        tomlContent += `headers = { `;
+                        const entries = Object.entries(serverConfig.headers);
+                        for (let i = 0; i < entries.length; i++) {
+                            const [key, value] = entries[i];
+                            tomlContent += `${JSON.stringify(key)} = "${value}"`;
+                            if (i < entries.length - 1) {
+                                tomlContent += ', ';
+                            }
+                        }
+                        tomlContent += ` }\n`;
+                    }
                 }
             }
             await (0, FileSystemUtils_1.writeGeneratedFile)(configPath, tomlContent);

package/dist/agents/CursorAgent.js

@@ -48,7 +48,7 @@ class CursorAgent extends AbstractAgent_1.AbstractAgent {
         return 'Cursor';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         // Cursor expects a YAML front-matter block with an `alwaysApply` flag.
@@ -56,7 +56,9 @@ class CursorAgent extends AbstractAgent_1.AbstractAgent {
         const frontMatter = ['---', 'alwaysApply: true', '---', ''].join('\n');
         const content = `${frontMatter}${concatenatedRules.trimStart()}`;
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
     }
     getDefaultOutputPath(projectRoot) {

package/dist/agents/RooCodeAgent.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RooCodeAgent = void 0;
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const AgentsMdAgent_1 = require("./AgentsMdAgent");
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+/**
+ * Agent for RooCode that writes to AGENTS.md and generates .roo/mcp.json
+ * with project-level MCP server configuration.
+ */
+class RooCodeAgent {
+    constructor() {
+        this.agentsMdAgent = new AgentsMdAgent_1.AgentsMdAgent();
+    }
+    getIdentifier() {
+        return 'roo';
+    }
+    getName() {
+        return 'RooCode';
+    }
+    getDefaultOutputPath(projectRoot) {
+        return {
+            instructions: path.join(projectRoot, 'AGENTS.md'),
+            mcp: path.join(projectRoot, '.roo', 'mcp.json'),
+        };
+    }
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
+        // First perform idempotent AGENTS.md write via composed AgentsMdAgent
+        await this.agentsMdAgent.applyRulerConfig(concatenatedRules, projectRoot, null, {
+            // Preserve explicit outputPath precedence semantics if provided.
+            outputPath: agentConfig?.outputPath ||
+                agentConfig?.outputPathInstructions ||
+                undefined,
+        }, backup);
+        // Now handle .roo/mcp.json configuration
+        const outputPaths = this.getDefaultOutputPath(projectRoot);
+        const mcpPath = path.resolve(projectRoot, agentConfig?.outputPathConfig ?? outputPaths['mcp']);
+        await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(mcpPath));
+        // Create base structure with mcpServers
+        let finalMcpConfig = {
+            mcpServers: {},
+        };
+        // Try to read existing .roo/mcp.json
+        let existingConfig = {};
+        try {
+            const existingContent = await fs_1.promises.readFile(mcpPath, 'utf-8');
+            const parsed = JSON.parse(existingContent);
+            if (parsed && typeof parsed === 'object') {
+                existingConfig = parsed;
+            }
+        }
+        catch {
+            // File doesn't exist or invalid JSON - start fresh
+            existingConfig = {};
+        }
+        // Merge MCP servers if we have ruler config
+        if (rulerMcpJson?.mcpServers) {
+            const existingServers = existingConfig.mcpServers || {};
+            const newServers = rulerMcpJson.mcpServers;
+            // Shallow merge: new servers override existing with same name
+            finalMcpConfig = {
+                mcpServers: {
+                    ...existingServers,
+                    ...newServers,
+                },
+            };
+        }
+        else if (existingConfig.mcpServers) {
+            // Keep existing servers if no new ones to add
+            finalMcpConfig = {
+                mcpServers: existingConfig.mcpServers,
+            };
+        }
+        // If neither condition is met, finalMcpConfig remains { mcpServers: {} }
+        // Write the config file with pretty JSON (2 spaces)
+        const newContent = JSON.stringify(finalMcpConfig, null, 2);
+        // Check if content has changed for idempotency
+        let existingContent = null;
+        try {
+            existingContent = await fs_1.promises.readFile(mcpPath, 'utf8');
+        }
+        catch {
+            existingContent = null;
+        }
+        if (existingContent !== null && existingContent === newContent) {
+            // No change; skip backup/write for idempotency
+            return;
+        }
+        // Backup (only if file existed and backup is enabled) then write new content
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(mcpPath);
+        }
+        await (0, FileSystemUtils_1.writeGeneratedFile)(mcpPath, newContent);
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return true;
+    }
+    getMcpServerKey() {
+        return 'mcpServers';
+    }
+}
+exports.RooCodeAgent = RooCodeAgent;

package/dist/agents/WindsurfAgent.js

@@ -48,15 +48,38 @@ class WindsurfAgent extends AbstractAgent_1.AbstractAgent {
         return 'Windsurf';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         // Windsurf expects a YAML front-matter block with a `trigger` flag.
         const frontMatter = ['---', 'trigger: always_on', '---', ''].join('\n');
         const content = `${frontMatter}${concatenatedRules.trimStart()}`;
+        const maxFileSize = 10000; // 10K characters
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
-        await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
+        // Check if content exceeds the 10K limit
+        if (content.length <= maxFileSize) {
+            // Content fits in single file - use original behavior
+            await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
+        }
+        else {
+            // Content exceeds limit - split into multiple files
+            console.warn(`[ruler] Warning: Windsurf rule content exceeds ${maxFileSize} characters (${content.length}). Splitting into multiple files.`);
+            const files = this.splitContentIntoFiles(concatenatedRules.trimStart(), frontMatter, maxFileSize);
+            // Write each split file
+            const rulesDir = path.dirname(absolutePath);
+            const baseName = path.basename(absolutePath, '.md');
+            for (let i = 0; i < files.length; i++) {
+                const fileName = `${baseName}_${i.toString().padStart(2, '0')}.md`;
+                const filePath = path.join(rulesDir, fileName);
+                if (backup) {
+                    await (0, FileSystemUtils_1.backupFile)(filePath);
+                }
+                await (0, FileSystemUtils_1.writeGeneratedFile)(filePath, files[i]);
+            }
+        }
     }
     getDefaultOutputPath(projectRoot) {
         return path.join(projectRoot, '.windsurf', 'rules', 'ruler_windsurf_instructions.md');
@@ -67,5 +90,69 @@ class WindsurfAgent extends AbstractAgent_1.AbstractAgent {
     supportsMcpRemote() {
         return true;
     }
+    /**
+     * Gets all actual output paths that will be created, including split files.
+     * This allows the gitignore system to know about split files before they're created.
+     */
+    getActualOutputPaths(concatenatedRules, projectRoot, agentConfig) {
+        const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
+        const absolutePath = path.resolve(projectRoot, output);
+        // Windsurf expects a YAML front-matter block with a `trigger` flag.
+        const frontMatter = ['---', 'trigger: always_on', '---', ''].join('\n');
+        const content = `${frontMatter}${concatenatedRules.trimStart()}`;
+        const maxFileSize = 10000; // 10K characters
+        // Check if content will be split
+        if (content.length <= maxFileSize) {
+            // Content fits in single file
+            return [absolutePath];
+        }
+        else {
+            // Content will be split - calculate how many files will be created
+            const files = this.splitContentIntoFiles(concatenatedRules.trimStart(), frontMatter, maxFileSize);
+            const rulesDir = path.dirname(absolutePath);
+            const baseName = path.basename(absolutePath, '.md');
+            const splitPaths = [];
+            for (let i = 0; i < files.length; i++) {
+                const fileName = `${baseName}_${i.toString().padStart(2, '0')}.md`;
+                const filePath = path.join(rulesDir, fileName);
+                splitPaths.push(filePath);
+            }
+            return splitPaths;
+        }
+    }
+    /**
+     * Splits content into multiple files, each under the specified size limit.
+     * Splits at the closest newline within the limit.
+     * Each file gets its own front-matter.
+     */
+    splitContentIntoFiles(rules, frontMatter, maxFileSize) {
+        const files = [];
+        const availableSpace = maxFileSize - frontMatter.length;
+        let remainingRules = rules;
+        while (remainingRules.length > 0) {
+            if (remainingRules.length <= availableSpace) {
+                // Remaining content fits in one file
+                files.push(`${frontMatter}${remainingRules}`);
+                break;
+            }
+            // Find the last newline within the available space
+            let splitIndex = availableSpace;
+            const searchSpace = remainingRules.substring(0, availableSpace);
+            const lastNewline = searchSpace.lastIndexOf('\n');
+            if (lastNewline > 0) {
+                // Split at the newline (include the newline in the current file)
+                splitIndex = lastNewline + 1;
+            }
+            else {
+                // No newline found within limit - split at the limit
+                // This shouldn't happen often but we handle it gracefully
+                splitIndex = availableSpace;
+            }
+            const chunk = remainingRules.substring(0, splitIndex);
+            files.push(`${frontMatter}${chunk}`);
+            remainingRules = remainingRules.substring(splitIndex);
+        }
+        return files;
+    }
 }
 exports.WindsurfAgent = WindsurfAgent;

package/dist/agents/index.js

@@ -26,6 +26,7 @@ const AgentsMdAgent_1 = require("./AgentsMdAgent");
 const QwenCodeAgent_1 = require("./QwenCodeAgent");
 const KiroAgent_1 = require("./KiroAgent");
 const WarpAgent_1 = require("./WarpAgent");
+const RooCodeAgent_1 = require("./RooCodeAgent");
 exports.allAgents = [
     new CopilotAgent_1.CopilotAgent(),
     new ClaudeAgent_1.ClaudeAgent(),
@@ -50,4 +51,5 @@ exports.allAgents = [
     new AgentsMdAgent_1.AgentsMdAgent(),
     new KiroAgent_1.KiroAgent(),
     new WarpAgent_1.WarpAgent(),
+    new RooCodeAgent_1.RooCodeAgent(),
 ];

package/dist/cli/commands.js

@@ -64,6 +64,11 @@ function run() {
             type: 'boolean',
             description: 'Enable nested rule loading from nested .ruler directories (default: disabled)',
             default: false,
+        })
+            .option('backup', {
+            type: 'boolean',
+            description: 'Enable/disable creation of .bak backup files (default: enabled)',
+            default: true,
         });
     }, handlers_1.applyHandler)
         .command('init', 'Scaffold a .ruler directory with default files', (y) => {

package/dist/cli/handlers.js

@@ -59,6 +59,7 @@ async function applyHandler(argv) {
     const dryRun = argv['dry-run'];
     const localOnly = argv['local-only'];
     const nested = argv.nested;
+    const backup = argv.backup;
     // Determine gitignore preference: CLI > TOML > Default (enabled)
     // yargs handles --no-gitignore by setting gitignore to false
     let gitignorePreference;
@@ -69,7 +70,7 @@ async function applyHandler(argv) {
         gitignorePreference = undefined; // Let TOML/default decide
     }
     try {
-        await (0, lib_1.applyAllAgentConfigs)(projectRoot, agents, configPath, mcpEnabled, mcpStrategy, gitignorePreference, verbose, dryRun, localOnly, nested);
+        await (0, lib_1.applyAllAgentConfigs)(projectRoot, agents, configPath, mcpEnabled, mcpStrategy, gitignorePreference, verbose, dryRun, localOnly, nested, backup);
         console.log('Ruler apply completed successfully.');
     }
     catch (err) {

package/dist/core/apply-engine.js

@@ -218,12 +218,12 @@ function selectAgentsToRun(allAgents, config) {
  * @param cliMcpStrategy MCP strategy from CLI
  * @returns Promise resolving to array of generated file paths
  */
-async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy) {
+async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true) {
     const allGeneratedPaths = [];
     for (const config of configurations) {
         console.log(`[ruler] Processing .ruler directory: ${config.rulerDir}`);
         const rulerRoot = path.dirname(config.rulerDir);
-        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
         allGeneratedPaths.push(...paths);
     }
     return allGeneratedPaths;
@@ -240,8 +240,8 @@ async function processHierarchicalConfigurations(agents, configurations, verbose
  * @param cliMcpStrategy MCP strategy from CLI
  * @returns Promise resolving to array of generated file paths
  */
-async function processSingleConfiguration(agents, configuration, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy) {
-    return await applyConfigurationsToAgents(agents, configuration.concatenatedRules, configuration.rulerMcpJson, configuration.config, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+async function processSingleConfiguration(agents, configuration, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true) {
+    return await applyConfigurationsToAgents(agents, configuration.concatenatedRules, configuration.rulerMcpJson, configuration.config, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
 }
 /**
  * Applies configurations to the selected agents (internal function).
@@ -254,7 +254,7 @@ async function processSingleConfiguration(agents, configuration, projectRoot, ve
  * @param dryRun Whether to perform a dry run
  * @returns Promise resolving to array of generated file paths
  */
-async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJson, config, projectRoot, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy) {
+async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJson, config, projectRoot, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true) {
     const generatedPaths = [];
     let agentsMdWritten = false;
     for (const agent of agents) {
@@ -263,12 +263,22 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
         (0, constants_1.logVerbose)(`Processing agent: ${agent.getName()}`, verbose);
         const agentConfig = config.agentConfigs[agent.getIdentifier()];
         // Collect output paths for .gitignore
-        const outputPaths = (0, agent_utils_1.getAgentOutputPaths)(agent, projectRoot, agentConfig);
+        let outputPaths;
+        // Special handling for Windsurf agent to account for file splitting
+        if (agent.getIdentifier() === 'windsurf' &&
+            'getActualOutputPaths' in agent) {
+            outputPaths = agent.getActualOutputPaths(concatenatedRules, projectRoot, agentConfig);
+        }
+        else {
+            outputPaths = (0, agent_utils_1.getAgentOutputPaths)(agent, projectRoot, agentConfig);
+        }
         (0, constants_1.logVerbose)(`Agent ${agent.getName()} output paths: ${outputPaths.join(', ')}`, verbose);
         generatedPaths.push(...outputPaths);
-        // Also add the backup file paths to the gitignore list
-        const backupPaths = outputPaths.map((p) => `${p}.bak`);
-        generatedPaths.push(...backupPaths);
+        // Only add the backup file paths to the gitignore list if backups are enabled
+        if (backup) {
+            const backupPaths = outputPaths.map((p) => `${p}.bak`);
+            generatedPaths.push(...backupPaths);
+        }
         if (dryRun) {
             (0, constants_1.logVerbose)(`DRY RUN: Would write rules to: ${outputPaths.join(', ')}`, verbose);
         }
@@ -299,15 +309,15 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 };
             }
             if (!skipApplyForThisAgent) {
-                await agent.applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, finalAgentConfig);
+                await agent.applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, finalAgentConfig, backup);
             }
         }
         // Handle MCP configuration
-        await handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        await handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
     return generatedPaths;
 }
-async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy) {
+async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true) {
     if (!(0, capabilities_1.agentSupportsMcp)(agent)) {
         (0, constants_1.logVerbose)(`Agent ${agent.getName()} does not support MCP - skipping MCP configuration`, verbose);
         return;
@@ -322,47 +332,49 @@ async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson,
         (0, constants_1.logVerbose)(`No compatible MCP servers found for ${agent.getName()} - skipping MCP configuration`, verbose);
         return;
     }
-    await updateGitignoreForMcpFile(dest, projectRoot, generatedPaths);
-    await applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose);
+    await updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup);
+    await applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup);
 }
-async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths) {
+async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup = true) {
     if (dest.startsWith(projectRoot)) {
         const relativeDest = path.relative(projectRoot, dest);
         generatedPaths.push(relativeDest);
-        generatedPaths.push(`${relativeDest}.bak`);
+        if (backup) {
+            generatedPaths.push(`${relativeDest}.bak`);
+        }
     }
 }
-async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose) {
+async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup = true) {
     // Prevent writing MCP configs outside the project root (e.g., legacy home-directory targets)
     if (!dest.startsWith(projectRoot)) {
         (0, constants_1.logVerbose)(`Skipping MCP config for ${agent.getName()} because target path is outside project: ${dest}`, verbose);
         return;
     }
     if (agent.getIdentifier() === 'openhands') {
-        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose);
+        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
     }
     if (agent.getIdentifier() === 'opencode') {
-        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose);
+        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
     }
-    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose);
+    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
 }
-async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose) {
+async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
     if (dryRun) {
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config by updating TOML file: ${dest}`, verbose);
     }
     else {
-        await (0, propagateOpenHandsMcp_1.propagateMcpToOpenHands)(filteredMcpJson, dest);
+        await (0, propagateOpenHandsMcp_1.propagateMcpToOpenHands)(filteredMcpJson, dest, backup);
     }
 }
-async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose) {
+async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
     if (dryRun) {
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config by updating OpenCode config file: ${dest}`, verbose);
     }
     else {
-        await (0, propagateOpenCodeMcp_1.propagateMcpToOpenCode)(filteredMcpJson, dest);
+        await (0, propagateOpenCodeMcp_1.propagateMcpToOpenCode)(filteredMcpJson, dest, backup);
     }
 }
-async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose) {
+async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup = true) {
     const strategy = cliMcpStrategy ??
         agentConfig?.mcp?.strategy ??
         config.mcp?.strategy ??
@@ -373,6 +385,10 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config to: ${dest}`, verbose);
     }
     else {
+        if (backup) {
+            const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+            await backupFile(dest);
+        }
         const existing = await (0, mcp_1.readNativeMcp)(dest);
         const merged = (0, merge_1.mergeMcp)(existing, filteredMcpJson, strategy, serverKey);
         await (0, mcp_1.writeNativeMcp)(dest, merged);
@@ -386,7 +402,7 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
  * @param cliGitignoreEnabled CLI gitignore setting
  * @param dryRun Whether to perform a dry run
  */
-async function updateGitignore(projectRoot, generatedPaths, config, cliGitignoreEnabled, dryRun) {
+async function updateGitignore(projectRoot, generatedPaths, config, cliGitignoreEnabled, dryRun, backup = true) {
     // Configuration precedence: CLI > TOML > Default (enabled)
     let gitignoreEnabled;
     if (cliGitignoreEnabled !== undefined) {
@@ -400,8 +416,10 @@ async function updateGitignore(projectRoot, generatedPaths, config, cliGitignore
     }
     if (gitignoreEnabled && generatedPaths.length > 0) {
         const uniquePaths = [...new Set(generatedPaths)];
-        // Add wildcard pattern for backup files
-        uniquePaths.push('*.bak');
+        // Add wildcard pattern for backup files only if backup is enabled
+        if (backup) {
+            uniquePaths.push('*.bak');
+        }
         if (uniquePaths.length > 0) {
             const prefix = (0, constants_1.actionPrefix)(dryRun);
             if (dryRun) {

package/dist/lib.js

@@ -17,7 +17,7 @@ const agents = agents_1.allAgents;
  * @param projectRoot Root directory of the project
  * @param includedAgents Optional list of agent name filters (case-insensitive substrings)
  */
-async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cliMcpEnabled = true, cliMcpStrategy, cliGitignoreEnabled, verbose = false, dryRun = false, localOnly = false, nested = false) {
+async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cliMcpEnabled = true, cliMcpStrategy, cliGitignoreEnabled, verbose = false, dryRun = false, localOnly = false, nested = false, backup = true) {
     // Load configuration and rules
     (0, constants_1.logVerbose)(`Loading configuration from project root: ${projectRoot}`, verbose);
     if (configPath) {
@@ -40,7 +40,7 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         normalizeAgentConfigs(rootConfig, agents);
         selectedAgents = (0, apply_engine_1.selectAgentsToRun)(agents, rootConfig);
         (0, constants_1.logVerbose)(`Selected ${selectedAgents.length} agents: ${selectedAgents.map((a) => a.getName()).join(', ')}`, verbose);
-        generatedPaths = await (0, apply_engine_1.processHierarchicalConfigurations)(selectedAgents, hierarchicalConfigs, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        generatedPaths = await (0, apply_engine_1.processHierarchicalConfigurations)(selectedAgents, hierarchicalConfigs, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
     else {
         const singleConfig = await (0, apply_engine_1.loadSingleConfiguration)(projectRoot, configPath, localOnly);
@@ -51,9 +51,9 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         normalizeAgentConfigs(singleConfig.config, agents);
         selectedAgents = (0, apply_engine_1.selectAgentsToRun)(agents, singleConfig.config);
         (0, constants_1.logVerbose)(`Selected ${selectedAgents.length} agents: ${selectedAgents.map((a) => a.getName()).join(', ')}`, verbose);
-        generatedPaths = await (0, apply_engine_1.processSingleConfiguration)(selectedAgents, singleConfig, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        generatedPaths = await (0, apply_engine_1.processSingleConfiguration)(selectedAgents, singleConfig, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
-    await (0, apply_engine_1.updateGitignore)(projectRoot, generatedPaths, loadedConfig, cliGitignoreEnabled, dryRun);
+    await (0, apply_engine_1.updateGitignore)(projectRoot, generatedPaths, loadedConfig, cliGitignoreEnabled, dryRun, backup);
 }
 /**
  * Normalizes per-agent config keys to agent identifiers for consistent lookup.

package/dist/mcp/capabilities.js

@@ -40,10 +40,24 @@ function filterMcpConfigForAgent(mcpConfig, agent) {
         const isStdio = hasCommand && !hasUrl;
         const isRemote = hasUrl && !hasCommand;
         // Include server if agent supports its type
-        if ((isStdio && capabilities.supportsStdio) ||
-            (isRemote && capabilities.supportsRemote)) {
+        if (isStdio && capabilities.supportsStdio) {
             filteredServers[serverName] = serverConfig;
         }
+        else if (isRemote && capabilities.supportsRemote) {
+            filteredServers[serverName] = serverConfig;
+        }
+        else if (isRemote &&
+            !capabilities.supportsRemote &&
+            capabilities.supportsStdio) {
+            // Transform remote server to stdio server using mcp-remote
+            const transformedConfig = {
+                command: 'npx',
+                args: ['-y', 'mcp-remote@latest', config.url],
+                ...Object.fromEntries(Object.entries(config).filter(([key]) => key !== 'url')),
+            };
+            filteredServers[serverName] = transformedConfig;
+        }
+        // Note: Mixed servers (both command and url) are excluded
     }
     return Object.keys(filteredServers).length > 0
         ? { mcpServers: filteredServers }

package/dist/mcp/propagateOpenCodeMcp.js

@@ -85,7 +85,7 @@ function transformToOpenCodeFormat(rulerMcp) {
         mcp: openCodeServers,
     };
 }
-async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath) {
+async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath, backup = true) {
     const rulerMcp = rulerMcpData || {};
     // Read existing OpenCode config if it exists
     let existingConfig = {};
@@ -108,5 +108,9 @@ async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath) {
         },
     };
     await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openCodeConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openCodeConfigPath);
+    }
     await fs.writeFile(openCodeConfigPath, JSON.stringify(finalConfig, null, 2) + '\n');
 }

package/dist/mcp/propagateOpenHandsMcp.js

@@ -90,7 +90,7 @@ function normalizeRemoteServerArray(entries) {
     // All entries are strings, keep as is
     return entries;
 }
-async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath) {
+async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath, backup = true) {
     const rulerMcp = rulerMcpData || {};
     // Always use the legacy Ruler MCP config format as input (top-level "mcpServers" key)
     const rulerServers = rulerMcp.mcpServers || {};
@@ -162,5 +162,9 @@ async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath) {
     config.mcp.sse_servers = normalizeRemoteServerArray(Array.from(existingSseServers.values()));
     config.mcp.shttp_servers = normalizeRemoteServerArray(Array.from(existingShttpServers.values()));
     await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openHandsConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openHandsConfigPath);
+    }
     await fs.writeFile(openHandsConfigPath, (0, toml_1.stringify)(config));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellectronica/ruler",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Ruler — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "scripts": {