@intellectronica/ruler 0.3.2 → 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/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/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

@@ -54,11 +54,32 @@ class WindsurfAgent extends AbstractAgent_1.AbstractAgent {
         // 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));
         if (backup) {
             await (0, FileSystemUtils_1.backupFile)(absolutePath);
         }
-        await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
+        // 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');
@@ -69,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/core/apply-engine.js

@@ -263,7 +263,15 @@ 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);
         // Only add the backup file paths to the gitignore list if backups are enabled

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/package.json

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