@intellectronica/ruler 0.3.10 → 0.3.12

package/dist/core/apply-engine.js

@@ -40,6 +40,7 @@ exports.processSingleConfiguration = processSingleConfiguration;
 exports.applyConfigurationsToAgents = applyConfigurationsToAgents;
 exports.updateGitignore = updateGitignore;
 const path = __importStar(require("path"));
+const fs_1 = require("fs");
 const FileSystemUtils = __importStar(require("./FileSystemUtils"));
 const RuleProcessor_1 = require("./RuleProcessor");
 const ConfigLoader_1 = require("./ConfigLoader");
@@ -51,16 +52,13 @@ const propagateOpenCodeMcp_1 = require("../mcp/propagateOpenCodeMcp");
 const agent_utils_1 = require("../agents/agent-utils");
 const capabilities_1 = require("../mcp/capabilities");
 const constants_1 = require("../constants");
-async function loadNestedConfigurations(projectRoot, configPath, localOnly) {
+async function loadNestedConfigurations(projectRoot, configPath, localOnly, resolvedNested) {
     const { dirs: rulerDirs } = await findRulerDirectories(projectRoot, localOnly, true);
-    const rootConfig = await (0, ConfigLoader_1.loadConfig)({
-        projectRoot,
-        configPath,
-    });
     const results = [];
     const rulerDirConfigs = await processIndependentRulerDirs(rulerDirs);
     for (const { rulerDir, files } of rulerDirConfigs) {
-        results.push(await createHierarchicalConfiguration(rulerDir, files, rootConfig));
+        const config = await loadConfigForRulerDir(rulerDir, configPath, resolvedNested);
+        results.push(await createHierarchicalConfiguration(rulerDir, files, config, configPath));
     }
     return results;
 }
@@ -77,14 +75,78 @@ async function processIndependentRulerDirs(rulerDirs) {
     }
     return results;
 }
-async function createHierarchicalConfiguration(rulerDir, files, rootConfig) {
+async function createHierarchicalConfiguration(rulerDir, files, config, cliConfigPath) {
     await warnAboutLegacyMcpJson(rulerDir);
     const concatenatedRules = (0, RuleProcessor_1.concatenateRules)(files, path.dirname(rulerDir));
+    const directoryRoot = path.dirname(rulerDir);
+    const localConfigPath = path.join(rulerDir, 'ruler.toml');
+    let configPathToUse = cliConfigPath;
+    try {
+        await fs_1.promises.access(localConfigPath);
+        configPathToUse = localConfigPath;
+    }
+    catch {
+        // fall back to CLI config or default resolution
+    }
+    const { loadUnifiedConfig } = await Promise.resolve().then(() => __importStar(require('./UnifiedConfigLoader')));
+    const unifiedConfig = await loadUnifiedConfig({
+        projectRoot: directoryRoot,
+        configPath: configPathToUse,
+    });
+    let rulerMcpJson = null;
+    if (unifiedConfig.mcp && Object.keys(unifiedConfig.mcp.servers).length > 0) {
+        rulerMcpJson = {
+            mcpServers: unifiedConfig.mcp.servers,
+        };
+    }
     return {
         rulerDir,
-        config: rootConfig,
+        config,
         concatenatedRules,
-        rulerMcpJson: null, // No nested MCP support - each level uses root config only
+        rulerMcpJson,
+    };
+}
+async function loadConfigForRulerDir(rulerDir, cliConfigPath, resolvedNested) {
+    const directoryRoot = path.dirname(rulerDir);
+    const localConfigPath = path.join(rulerDir, 'ruler.toml');
+    let hasLocalConfig = false;
+    try {
+        await fs_1.promises.access(localConfigPath);
+        hasLocalConfig = true;
+    }
+    catch {
+        hasLocalConfig = false;
+    }
+    const loaded = await (0, ConfigLoader_1.loadConfig)({
+        projectRoot: directoryRoot,
+        configPath: hasLocalConfig ? localConfigPath : cliConfigPath,
+    });
+    const cloned = cloneLoadedConfig(loaded);
+    if (resolvedNested) {
+        if (hasLocalConfig && loaded.nestedDefined && loaded.nested === false) {
+            (0, constants_1.logWarn)(`Nested mode is enabled but ${localConfigPath} sets nested = false. Continuing with nested processing.`);
+        }
+        cloned.nested = true;
+        cloned.nestedDefined = true;
+    }
+    return cloned;
+}
+function cloneLoadedConfig(config) {
+    const clonedAgentConfigs = {};
+    for (const [agent, agentConfig] of Object.entries(config.agentConfigs)) {
+        clonedAgentConfigs[agent] = {
+            ...agentConfig,
+            mcp: agentConfig.mcp ? { ...agentConfig.mcp } : undefined,
+        };
+    }
+    return {
+        defaultAgents: config.defaultAgents ? [...config.defaultAgents] : undefined,
+        agentConfigs: clonedAgentConfigs,
+        cliAgents: config.cliAgents ? [...config.cliAgents] : undefined,
+        mcp: config.mcp ? { ...config.mcp } : undefined,
+        gitignore: config.gitignore ? { ...config.gitignore } : undefined,
+        nested: config.nested,
+        nestedDefined: config.nestedDefined,
     };
 }
 /**
@@ -120,7 +182,7 @@ async function findRulerDirectories(projectRoot, localOnly, hierarchical) {
 async function warnAboutLegacyMcpJson(rulerDir) {
     try {
         const legacyMcpPath = path.join(rulerDir, 'mcp.json');
-        await (await Promise.resolve().then(() => __importStar(require('fs/promises')))).access(legacyMcpPath);
+        await fs_1.promises.access(legacyMcpPath);
         (0, constants_1.logWarn)('Warning: Using legacy .ruler/mcp.json. Please migrate to ruler.toml. This fallback will be removed in a future release.');
     }
     catch {
@@ -171,13 +233,14 @@ async function loadSingleConfiguration(projectRoot, configPath, localOnly) {
  * @param cliMcpStrategy MCP strategy from CLI
  * @returns Promise resolving to array of generated file paths
  */
-async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true) {
+async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true, skillsEnabled = true) {
     const allGeneratedPaths = [];
     for (const config of configurations) {
         (0, constants_1.logVerboseInfo)(`Processing .ruler directory: ${config.rulerDir}`, verbose, dryRun);
         const rulerRoot = path.dirname(config.rulerDir);
-        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
-        allGeneratedPaths.push(...paths);
+        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabled);
+        const normalizedPaths = paths.map((p) => path.isAbsolute(p) ? p : path.join(rulerRoot, p));
+        allGeneratedPaths.push(...normalizedPaths);
     }
     return allGeneratedPaths;
 }
@@ -193,8 +256,43 @@ 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, backup = true) {
-    return await applyConfigurationsToAgents(agents, configuration.concatenatedRules, configuration.rulerMcpJson, configuration.config, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
+async function processSingleConfiguration(agents, configuration, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true, skillsEnabled = true) {
+    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.
+ * 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) {
+        return rulerMcpJson;
+    }
+    // Check if .skillz directory exists
+    try {
+        const { SKILLZ_DIR } = await Promise.resolve().then(() => __importStar(require('../constants')));
+        const skillzPath = path.join(projectRoot, SKILLZ_DIR);
+        await fs_1.promises.access(skillzPath);
+        // Skills exist, add Skillz MCP server
+        const { buildSkillzMcpConfig } = await Promise.resolve().then(() => __importStar(require('./SkillsProcessor')));
+        const skillzMcp = buildSkillzMcpConfig(projectRoot);
+        // 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);
+        return {
+            ...baseConfig,
+            mcpServers: {
+                ...mcpServers,
+                ...skillzMcp,
+            },
+        };
+    }
+    catch {
+        // No .skillz directory, return original config
+        return rulerMcpJson;
+    }
 }
 /**
  * Applies configurations to the selected agents (internal function).
@@ -207,23 +305,22 @@ 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, backup = true) {
+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()];
         // Collect output paths for .gitignore
-        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);
-        }
+        const 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
@@ -247,7 +344,7 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 }
             }
             let finalAgentConfig = agentConfig;
-            if (agent.getIdentifier() === 'augmentcode' && rulerMcpJson) {
+            if (agent.getIdentifier() === 'augmentcode' && augmentedRulerMcpJson) {
                 const resolvedStrategy = cliMcpStrategy ??
                     agentConfig?.mcp?.strategy ??
                     config.mcp?.strategy ??
@@ -261,25 +358,59 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 };
             }
             if (!skipApplyForThisAgent) {
-                await agent.applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, finalAgentConfig, backup);
+                await agent.applyRulerConfig(concatenatedRules, projectRoot, augmentedRulerMcpJson, finalAgentConfig, backup);
             }
         }
         // Handle MCP configuration
-        await handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
+        await handleMcpConfiguration(agent, agentConfig, config, augmentedRulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabled);
     }
     return generatedPaths;
 }
-async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true) {
+async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true, skillsEnabled = true) {
     if (!(0, capabilities_1.agentSupportsMcp)(agent)) {
         (0, constants_1.logVerbose)(`Agent ${agent.getName()} does not support MCP - skipping MCP configuration`, verbose);
         return;
     }
     const dest = await (0, mcp_1.getNativeMcpPath)(agent.getName(), projectRoot);
     const mcpEnabledForAgent = cliMcpEnabled && (agentConfig?.mcp?.enabled ?? config.mcp?.enabled ?? true);
-    if (!dest || !mcpEnabledForAgent || !rulerMcpJson) {
+    if (!dest || !mcpEnabledForAgent) {
         return;
     }
-    const filteredMcpJson = (0, capabilities_1.filterMcpConfigForAgent)(rulerMcpJson, agent);
+    let filteredMcpJson = rulerMcpJson
+        ? (0, capabilities_1.filterMcpConfigForAgent)(rulerMcpJson, agent)
+        : null;
+    // Add Skillz MCP server for agents that support stdio but not native skills
+    // Only add if skills are enabled
+    if (skillsEnabled &&
+        agent.supportsMcpStdio?.() &&
+        !agent.supportsNativeSkills?.()) {
+        // Check if .skillz directory exists
+        try {
+            const { SKILLZ_DIR } = await Promise.resolve().then(() => __importStar(require('../constants')));
+            const skillzPath = path.join(projectRoot, SKILLZ_DIR);
+            await fs_1.promises.access(skillzPath);
+            // Skills exist, add Skillz MCP server
+            const { buildSkillzMcpConfig } = await Promise.resolve().then(() => __importStar(require('./SkillsProcessor')));
+            const skillzMcp = buildSkillzMcpConfig(projectRoot);
+            // Merge Skillz server into MCP config
+            // Initialize empty config if null
+            if (!filteredMcpJson) {
+                filteredMcpJson = { mcpServers: {} };
+            }
+            const mcpServers = filteredMcpJson.mcpServers || {};
+            filteredMcpJson = {
+                ...filteredMcpJson,
+                mcpServers: {
+                    ...mcpServers,
+                    ...skillzMcp,
+                },
+            };
+            (0, constants_1.logVerboseInfo)(`Added Skillz MCP server for ${agent.getName()}`, verbose, dryRun);
+        }
+        catch {
+            // No .skillz directory, skip adding Skillz server
+        }
+    }
     if (!filteredMcpJson) {
         (0, constants_1.logVerbose)(`No compatible MCP servers found for ${agent.getName()} - skipping MCP configuration`, verbose);
         return;
@@ -369,6 +500,35 @@ function transformMcpForClaude(mcpJson) {
     transformedMcp.mcpServers = transformedServers;
     return transformedMcp;
 }
+/**
+ * Transform MCP server types for Kilo Code compatibility.
+ * Kilo Code expects "streamable-http" for remote HTTP servers, not "remote".
+ */
+function transformMcpForKiloCode(mcpJson) {
+    if (!mcpJson.mcpServers || typeof mcpJson.mcpServers !== 'object') {
+        return mcpJson;
+    }
+    const transformedMcp = { ...mcpJson };
+    const transformedServers = {};
+    for (const [name, serverDef] of Object.entries(mcpJson.mcpServers)) {
+        if (serverDef && typeof serverDef === 'object') {
+            const server = serverDef;
+            const transformedServer = { ...server };
+            // Transform type: "remote" to "streamable-http" for HTTP-based servers
+            if (server.type === 'remote' &&
+                server.url &&
+                typeof server.url === 'string') {
+                transformedServer.type = 'streamable-http';
+            }
+            transformedServers[name] = transformedServer;
+        }
+        else {
+            transformedServers[name] = serverDef;
+        }
+    }
+    transformedMcp.mcpServers = transformedServers;
+    return transformedMcp;
+}
 async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup = true) {
     const strategy = cliMcpStrategy ??
         agentConfig?.mcp?.strategy ??
@@ -385,11 +545,14 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config to: ${dest}`, verbose);
     }
     else {
-        // Transform MCP config for Claude Code compatibility
+        // Transform MCP config for agent-specific compatibility
         let mcpToMerge = filteredMcpJson;
         if (agent.getIdentifier() === 'claude') {
             mcpToMerge = transformMcpForClaude(filteredMcpJson);
         }
+        else if (agent.getIdentifier() === 'kilocode') {
+            mcpToMerge = transformMcpForKiloCode(filteredMcpJson);
+        }
         const existing = await (0, mcp_1.readNativeMcp)(dest);
         const merged = (0, merge_1.mergeMcp)(existing, mcpToMerge, strategy, serverKey);
         // Firebase Studio (IDX) expects no "type" fields in .idx/mcp.json server entries.

package/dist/lib.js

@@ -1,7 +1,41 @@
 "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.allAgents = void 0;
 exports.applyAllAgentConfigs = applyAllAgentConfigs;
+const path = __importStar(require("path"));
 const agents_1 = require("./agents");
 Object.defineProperty(exports, "allAgents", { enumerable: true, get: function () { return agents_1.allAgents; } });
 const constants_1 = require("./constants");
@@ -9,6 +43,16 @@ const apply_engine_1 = require("./core/apply-engine");
 const config_utils_1 = require("./core/config-utils");
 const agent_selection_1 = require("./core/agent-selection");
 const agents = agents_1.allAgents;
+/**
+ * Resolves skills enabled state based on precedence: CLI flag > ruler.toml > default (enabled)
+ */
+function resolveSkillsEnabled(cliFlag, configSetting) {
+    return cliFlag !== undefined
+        ? cliFlag
+        : configSetting !== undefined
+            ? configSetting
+            : true; // default to enabled
+}
 /**
  * Applies ruler configurations for all supported AI agents.
  * @param projectRoot Root directory of the project
@@ -18,7 +62,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, backup = true) {
+async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cliMcpEnabled = true, cliMcpStrategy, cliGitignoreEnabled, verbose = false, dryRun = false, localOnly = false, nested = false, backup = true, skillsEnabled) {
     // Load configuration and rules
     (0, constants_1.logVerbose)(`Loading configuration from project root: ${projectRoot}`, verbose);
     if (configPath) {
@@ -28,20 +72,35 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
     let generatedPaths;
     let loadedConfig;
     if (nested) {
-        const hierarchicalConfigs = await (0, apply_engine_1.loadNestedConfigurations)(projectRoot, configPath, localOnly);
+        const hierarchicalConfigs = await (0, apply_engine_1.loadNestedConfigurations)(projectRoot, configPath, localOnly, nested);
         if (hierarchicalConfigs.length === 0) {
             throw new Error('No .ruler directories found');
         }
+        (0, constants_1.logWarn)('Nested mode is experimental and may change in future releases.', dryRun);
         // Use the root config for agent selection (all levels share the same agent settings)
-        const rootConfig = hierarchicalConfigs[0].config;
+        const rootConfigEntry = selectRootConfiguration(hierarchicalConfigs, projectRoot);
+        const rootConfig = rootConfigEntry.config;
         loadedConfig = rootConfig;
         rootConfig.cliAgents = includedAgents;
         (0, constants_1.logVerbose)(`Loaded ${hierarchicalConfigs.length} .ruler directory configurations`, verbose);
         (0, constants_1.logVerbose)(`Root configuration has ${Object.keys(rootConfig.agentConfigs).length} agent configs`, verbose);
-        normalizeAgentConfigs(rootConfig, agents);
+        for (const configEntry of hierarchicalConfigs) {
+            normalizeAgentConfigs(configEntry.config, agents);
+        }
         selectedAgents = (0, agent_selection_1.resolveSelectedAgents)(rootConfig, agents);
         (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, backup);
+        // Propagate skills if enabled - do this for each nested directory
+        const skillsEnabledResolved = resolveSkillsEnabled(skillsEnabled, rootConfig.skills?.enabled);
+        if (skillsEnabledResolved) {
+            const { propagateSkills } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
+            // Propagate skills for each nested .ruler directory
+            for (const configEntry of hierarchicalConfigs) {
+                const nestedRoot = path.dirname(configEntry.rulerDir);
+                (0, constants_1.logVerbose)(`Propagating skills for nested directory: ${nestedRoot}`, verbose);
+                await propagateSkills(nestedRoot, selectedAgents, skillsEnabledResolved, verbose, dryRun);
+            }
+        }
+        generatedPaths = await (0, apply_engine_1.processHierarchicalConfigurations)(selectedAgents, hierarchicalConfigs, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabledResolved);
     }
     else {
         const singleConfig = await (0, apply_engine_1.loadSingleConfiguration)(projectRoot, configPath, localOnly);
@@ -52,9 +111,24 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         normalizeAgentConfigs(singleConfig.config, agents);
         selectedAgents = (0, agent_selection_1.resolveSelectedAgents)(singleConfig.config, agents);
         (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, backup);
+        // Propagate skills if enabled
+        const skillsEnabledResolved = resolveSkillsEnabled(skillsEnabled, singleConfig.config.skills?.enabled);
+        if (skillsEnabledResolved) {
+            const { propagateSkills } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
+            await propagateSkills(projectRoot, selectedAgents, skillsEnabledResolved, verbose, dryRun);
+        }
+        generatedPaths = await (0, apply_engine_1.processSingleConfiguration)(selectedAgents, singleConfig, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup, skillsEnabledResolved);
     }
-    await (0, apply_engine_1.updateGitignore)(projectRoot, generatedPaths, loadedConfig, cliGitignoreEnabled, dryRun);
+    // Add skills-generated paths to gitignore if skills are enabled
+    let allGeneratedPaths = generatedPaths;
+    const skillsEnabledForGitignore = resolveSkillsEnabled(skillsEnabled, loadedConfig.skills?.enabled);
+    if (skillsEnabledForGitignore) {
+        // Skills enabled by default or explicitly
+        const { getSkillsGitignorePaths } = await Promise.resolve().then(() => __importStar(require('./core/SkillsProcessor')));
+        const skillsPaths = await getSkillsGitignorePaths(projectRoot);
+        allGeneratedPaths = [...generatedPaths, ...skillsPaths];
+    }
+    await (0, apply_engine_1.updateGitignore)(projectRoot, allGeneratedPaths, loadedConfig, cliGitignoreEnabled, dryRun);
 }
 /**
  * Normalizes per-agent config keys to agent identifiers for consistent lookup.
@@ -66,3 +140,27 @@ function normalizeAgentConfigs(config, agents) {
     // Normalize per-agent config keys to agent identifiers (exact match or substring match)
     config.agentConfigs = (0, config_utils_1.mapRawAgentConfigs)(config.agentConfigs, agents);
 }
+function selectRootConfiguration(configurations, projectRoot) {
+    if (configurations.length === 0) {
+        throw new Error('No hierarchical configurations available');
+    }
+    const normalizedProjectRoot = path.resolve(projectRoot);
+    let bestIndex = -1;
+    let bestDepth = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < configurations.length; i++) {
+        const entry = configurations[i];
+        const normalizedDir = path.resolve(entry.rulerDir);
+        if (!normalizedDir.startsWith(normalizedProjectRoot)) {
+            continue;
+        }
+        const depth = normalizedDir.split(path.sep).length;
+        if (depth < bestDepth) {
+            bestDepth = depth;
+            bestIndex = i;
+        }
+    }
+    if (bestIndex === -1) {
+        return configurations[0];
+    }
+    return configurations[bestIndex];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intellectronica/ruler",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "description": "Ruler — apply the same rules to all coding agents",
   "main": "dist/lib.js",
   "scripts": {
@@ -35,6 +35,9 @@
     "url": "https://github.com/intellectronica/ruler/issues"
   },
   "homepage": "https://ai.intellectronica.net/ruler",
+  "engines": {
+    "node": ">=18"
+  },
   "files": [
     "dist",
     "README.md",
@@ -47,22 +50,23 @@
     "@types/iarna__toml": "^2.0.5",
     "@types/jest": "^29.5.14",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.15.24",
-    "@types/yargs": "^17.0.33",
-    "@typescript-eslint/eslint-plugin": "^8.32.1",
-    "@typescript-eslint/parser": "^8.32.1",
-    "eslint": "^8.57.1",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-prettier": "^5.4.0",
+    "@types/node": "^24.9.2",
+    "@types/yargs": "^17.0.34",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^9.38.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
     "jest": "^29.7.0",
-    "prettier": "^3.5.3",
-    "ts-jest": "^29.3.4",
-    "typescript": "^5.8.3"
+    "prettier": "^3.6.2",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2"
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "js-yaml": "^4.1.0",
-    "yargs": "^17.7.2",
-    "zod": "^3.25.28"
+    "yargs": "^18.0.0",
+    "zod": "^4.1.12"
   }
 }