@intellectronica/ruler 0.3.23 → 0.3.25

package/README.md

@@ -633,7 +633,7 @@ For agents that support MCP but don't have native skills support, Ruler automati
 
 1. Copies skills to `.skillz/` directory
 2. Configures a Skillz MCP server in the agent's configuration
-3. Uses `uvx` to launch the server with the absolute path to `.skillz`
+3. Uses `uvx` to launch the server with the project-relative path to `.skillz`
 
 Agents using native skills support (Claude Code, GitHub Copilot, Kilo Code, OpenAI Codex CLI, OpenCode, Pi Coding Agent, Goose, Amp, Mistral Vibe, Roo Code, Gemini CLI, and Cursor) **do not** use the Skillz MCP server and instead use their own native skills directories.
 
@@ -642,7 +642,7 @@ Example auto-generated MCP server configuration:
 ```toml
 [mcp_servers.skillz]
 command = "uvx"
-args = ["skillz@latest", "/absolute/path/to/project/.skillz"]
+args = ["skillz@latest", ".skillz"]
 ```
 
 ### `.gitignore` Integration

package/dist/agents/AbstractAgent.js

@@ -79,6 +79,13 @@ class AbstractAgent {
     supportsMcpRemote() {
         return false;
     }
+    /**
+     * Returns whether this agent supports MCP server timeout configuration.
+     * Defaults to false if not overridden.
+     */
+    supportsMcpTimeout() {
+        return false;
+    }
     /**
      * Returns whether this agent has native skills support.
      * Defaults to false if not overridden.

package/dist/agents/OpenCodeAgent.js

@@ -95,6 +95,9 @@ class OpenCodeAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsMcpTimeout() {
+        return true;
+    }
     supportsNativeSkills() {
         return true;
     }

package/dist/core/SkillsProcessor.js

@@ -808,7 +808,7 @@ async function propagateSkillsForSkillz(projectRoot, options) {
     if (options.dryRun) {
         return [
             `Copy skills from ${constants_1.RULER_SKILLS_PATH} to ${constants_1.SKILLZ_DIR}`,
-            `Configure Skillz MCP server with absolute path to ${constants_1.SKILLZ_DIR}`,
+            `Configure Skillz MCP server with path to ${constants_1.SKILLZ_DIR}`,
         ];
     }
     // Use atomic replace: copy to temp, then rename
@@ -843,11 +843,11 @@ async function propagateSkillsForSkillz(projectRoot, options) {
  * Builds MCP config for Skillz server.
  */
 function buildSkillzMcpConfig(projectRoot) {
-    const skillzAbsPath = path.resolve(projectRoot, constants_1.SKILLZ_DIR);
+    void projectRoot;
     return {
         [constants_1.SKILLZ_MCP_SERVER_NAME]: {
             command: 'uvx',
-            args: ['skillz@latest', skillzAbsPath],
+            args: ['skillz@latest', constants_1.SKILLZ_DIR],
         },
     };
 }

package/dist/core/UnifiedConfigLoader.js

@@ -182,6 +182,9 @@ async function loadUnifiedConfig(options) {
                 if (serverDef.headers && typeof serverDef.headers === 'object') {
                     server.headers = Object.fromEntries(Object.entries(serverDef.headers).filter(([, v]) => typeof v === 'string'));
                 }
+                if (typeof serverDef.timeout === 'number') {
+                    server.timeout = serverDef.timeout;
+                }
                 // Validate server configuration
                 const hasCommand = !!server.command;
                 const hasUrl = !!server.url;
@@ -301,6 +304,9 @@ async function loadUnifiedConfig(options) {
                     if (def.headers && typeof def.headers === 'object') {
                         server.headers = Object.fromEntries(Object.entries(def.headers).filter(([, v]) => typeof v === 'string'));
                     }
+                    if (typeof def.timeout === 'number') {
+                        server.timeout = def.timeout;
+                    }
                     // Derive type
                     if (server.url)
                         server.type = 'remote';

package/dist/core/apply-engine.js

@@ -260,13 +260,12 @@ async function processSingleConfiguration(agents, configuration, projectRoot, ve
     return await applyConfigurationsToAgents(agents, configuration.concatenatedRules, configuration.rulerMcpJson, configuration.config, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabled);
 }
 /**
- * Adds Skillz MCP server to rulerMcpJson if skills exist and any agent needs it.
+ * Adds Skillz MCP server to rulerMcpJson if skills exist and this agent needs it.
  * Returns augmented MCP config or original if no changes needed.
  */
-async function addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agents, verbose) {
-    // Check if any agent supports MCP stdio but not native skills
-    const hasAgentNeedingSkillz = agents.some((agent) => agent.supportsMcpStdio?.() && !agent.supportsNativeSkills?.());
-    if (!hasAgentNeedingSkillz) {
+async function addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agent, verbose) {
+    // Check if this agent supports MCP stdio but not native skills
+    if (!agent.supportsMcpStdio?.() || agent.supportsNativeSkills?.()) {
         return rulerMcpJson;
     }
     // Check if .skillz directory exists
@@ -280,7 +279,7 @@ async function addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agents, ver
         // Initialize empty config if null
         const baseConfig = rulerMcpJson || { mcpServers: {} };
         const mcpServers = baseConfig.mcpServers || {};
-        (0, constants_1.logVerbose)('Adding Skillz MCP server to configuration for agents that need it', verbose);
+        (0, constants_1.logVerbose)(`Adding Skillz MCP server to configuration for ${agent.getName()}`, verbose);
         return {
             ...baseConfig,
             mcpServers: {
@@ -308,17 +307,13 @@ async function addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agents, ver
 async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJson, config, projectRoot, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true, skillsEnabled = true) {
     const generatedPaths = [];
     let agentsMdWritten = false;
-    // Add Skillz MCP server to rulerMcpJson if skills are enabled
-    // This must happen before calling agent.applyRulerConfig() so that agents
-    // that handle MCP internally (e.g. Codex, Gemini) receive the Skillz server
-    let augmentedRulerMcpJson = rulerMcpJson;
-    if (skillsEnabled && !dryRun) {
-        augmentedRulerMcpJson = await addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agents, verbose);
-    }
     for (const agent of agents) {
         (0, constants_1.logInfo)(`Applying rules for ${agent.getName()}...`, dryRun);
         (0, constants_1.logVerbose)(`Processing agent: ${agent.getName()}`, verbose);
         const agentConfig = config.agentConfigs[agent.getIdentifier()];
+        const agentRulerMcpJson = skillsEnabled && !dryRun
+            ? await addSkillzMcpServerIfNeeded(rulerMcpJson, projectRoot, agent, verbose)
+            : rulerMcpJson;
         // Collect output paths for .gitignore
         const outputPaths = (0, agent_utils_1.getAgentOutputPaths)(agent, projectRoot, agentConfig);
         (0, constants_1.logVerbose)(`Agent ${agent.getName()} output paths: ${outputPaths.join(', ')}`, verbose);
@@ -344,7 +339,7 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 }
             }
             let finalAgentConfig = agentConfig;
-            if (agent.getIdentifier() === 'augmentcode' && augmentedRulerMcpJson) {
+            if (agent.getIdentifier() === 'augmentcode' && agentRulerMcpJson) {
                 const resolvedStrategy = cliMcpStrategy ??
                     agentConfig?.mcp?.strategy ??
                     config.mcp?.strategy ??
@@ -358,11 +353,11 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 };
             }
             if (!skipApplyForThisAgent) {
-                await agent.applyRulerConfig(concatenatedRules, projectRoot, augmentedRulerMcpJson, finalAgentConfig, backup);
+                await agent.applyRulerConfig(concatenatedRules, projectRoot, agentRulerMcpJson, finalAgentConfig, backup);
             }
         }
         // Handle MCP configuration
-        await handleMcpConfiguration(agent, agentConfig, config, augmentedRulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabled);
+        await handleMcpConfiguration(agent, agentConfig, config, agentRulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabled);
     }
     return generatedPaths;
 }
@@ -427,17 +422,49 @@ async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, back
         }
     }
 }
+function sanitizeMcpTimeoutsForAgent(agent, mcpJson, dryRun) {
+    if (agent.supportsMcpTimeout?.()) {
+        return mcpJson;
+    }
+    if (!mcpJson.mcpServers || typeof mcpJson.mcpServers !== 'object') {
+        return mcpJson;
+    }
+    const servers = mcpJson.mcpServers;
+    const sanitizedServers = {};
+    const strippedTimeouts = [];
+    for (const [name, serverDef] of Object.entries(servers)) {
+        if (serverDef && typeof serverDef === 'object') {
+            const copy = { ...serverDef };
+            if ('timeout' in copy) {
+                delete copy.timeout;
+                strippedTimeouts.push(name);
+            }
+            sanitizedServers[name] = copy;
+        }
+        else {
+            sanitizedServers[name] = serverDef;
+        }
+    }
+    if (strippedTimeouts.length > 0) {
+        (0, constants_1.logWarn)(`${agent.getName()} does not support MCP server timeout configuration; ignoring timeout for: ${strippedTimeouts.join(', ')}`, dryRun);
+    }
+    return {
+        ...mcpJson,
+        mcpServers: sanitizedServers,
+    };
+}
 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;
     }
+    const agentMcpJson = sanitizeMcpTimeoutsForAgent(agent, filteredMcpJson, dryRun);
     if (agent.getIdentifier() === 'openhands') {
-        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenHandsMcpConfiguration(agentMcpJson, dest, dryRun, verbose, backup);
     }
     if (agent.getIdentifier() === 'opencode') {
-        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenCodeMcpConfiguration(agentMcpJson, dest, dryRun, verbose, backup);
     }
     // Agents that handle MCP configuration internally should not have external MCP handling
     if (agent.getIdentifier() === 'zed' ||
@@ -447,7 +474,7 @@ async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig,
         (0, constants_1.logVerbose)(`Skipping external MCP config for ${agent.getName()} - handled internally by agent`, verbose);
         return;
     }
-    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
+    return await applyStandardMcpConfiguration(agent, agentMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
 }
 async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
     if (dryRun) {

package/dist/mcp/propagateOpenCodeMcp.js

@@ -63,6 +63,9 @@ function transformToOpenCodeFormat(rulerMcp) {
             if (serverDef.headers) {
                 openCodeServer.headers = serverDef.headers;
             }
+            if (typeof serverDef.timeout === 'number') {
+                openCodeServer.timeout = serverDef.timeout;
+            }
         }
         else if (isLocalServer(serverDef)) {
             openCodeServer.type = 'local';
@@ -74,6 +77,9 @@ function transformToOpenCodeFormat(rulerMcp) {
             if (serverDef.env) {
                 openCodeServer.environment = serverDef.env;
             }
+            if (typeof serverDef.timeout === 'number') {
+                openCodeServer.timeout = serverDef.timeout;
+            }
         }
         else {
             continue;

package/package.json

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