@intellectronica/ruler 0.3.40 → 0.3.42

package/dist/core/SubagentsProcessor.js

@@ -62,16 +62,13 @@ async function discoverSubagents(projectRoot) {
     catch {
         return { subagents: [], warnings: [] };
     }
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    const mdFiles = entries
-        .filter((entry) => entry.isFile() && entry.name.endsWith('.md'))
-        .map((entry) => path.join(dir, entry.name))
-        .sort();
+    const mdFiles = await listMarkdownFilesRecursive(dir);
     const subagents = [];
     const warnings = [];
     for (const filePath of mdFiles) {
         const info = await (0, SubagentsUtils_1.loadSubagentFile)(filePath);
         if (info.valid) {
+            info.sourceRelativePath = path.relative(dir, filePath);
             subagents.push(info);
         }
         else if (info.error) {
@@ -80,6 +77,22 @@ async function discoverSubagents(projectRoot) {
     }
     return { subagents, warnings };
 }
+async function listMarkdownFilesRecursive(dir) {
+    const results = [];
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const nested = await listMarkdownFilesRecursive(fullPath);
+            results.push(...nested);
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+            results.push(fullPath);
+        }
+    }
+    return results.sort();
+}
 const SUBAGENT_TARGET_TO_IDENTIFIERS = new Map([
     ['claude', ['claude']],
     ['cursor', ['cursor']],
@@ -167,7 +180,9 @@ async function writeAgentsDirectoryAtomic(targetDir, files) {
     await fs.mkdir(tempDir, { recursive: true });
     try {
         for (const { name, content } of files) {
-            await fs.writeFile(path.join(tempDir, name), content, 'utf8');
+            const outputPath = path.join(tempDir, name);
+            await fs.mkdir(path.dirname(outputPath), { recursive: true });
+            await fs.writeFile(outputPath, content, 'utf8');
         }
         try {
             await fs.rm(targetDir, { recursive: true, force: true });
@@ -187,6 +202,19 @@ async function writeAgentsDirectoryAtomic(targetDir, files) {
         throw error;
     }
 }
+function getSourceRelativeMdPath(sub) {
+    const fromSource = sub.sourceRelativePath;
+    if (typeof fromSource === 'string' &&
+        fromSource.length > 0 &&
+        !path.isAbsolute(fromSource) &&
+        !fromSource.startsWith('..')) {
+        return fromSource;
+    }
+    return `${sub.name}.md`;
+}
+function withExtension(filePath, ext) {
+    return filePath.replace(/\.md$/i, ext);
+}
 function buildClaudeFile(sub) {
     const fm = sub.frontmatter;
     const meta = {
@@ -276,10 +304,10 @@ async function propagateSubagentsForClaude(projectRoot, subagents, options) {
         return [];
     const targetDir = path.join(projectRoot, constants_1.CLAUDE_SUBAGENTS_PATH);
     if (options.dryRun) {
-        return subagents.map((s) => `Write ${path.join(constants_1.CLAUDE_SUBAGENTS_PATH, `${s.name}.md`)}`);
+        return subagents.map((s) => `Write ${path.join(constants_1.CLAUDE_SUBAGENTS_PATH, getSourceRelativeMdPath(s))}`);
     }
     const files = subagents.map((s) => ({
-        name: `${s.name}.md`,
+        name: getSourceRelativeMdPath(s),
         content: buildClaudeFile(s),
     }));
     await writeAgentsDirectoryAtomic(targetDir, files);
@@ -290,10 +318,10 @@ async function propagateSubagentsForCursor(projectRoot, subagents, options) {
         return [];
     const targetDir = path.join(projectRoot, constants_1.CURSOR_SUBAGENTS_PATH);
     if (options.dryRun) {
-        return subagents.map((s) => `Write ${path.join(constants_1.CURSOR_SUBAGENTS_PATH, `${s.name}.md`)}`);
+        return subagents.map((s) => `Write ${path.join(constants_1.CURSOR_SUBAGENTS_PATH, getSourceRelativeMdPath(s))}`);
     }
     const files = subagents.map((s) => ({
-        name: `${s.name}.md`,
+        name: getSourceRelativeMdPath(s),
         content: buildCursorFile(s),
     }));
     await writeAgentsDirectoryAtomic(targetDir, files);
@@ -304,10 +332,10 @@ async function propagateSubagentsForCodex(projectRoot, subagents, options) {
         return [];
     const targetDir = path.join(projectRoot, constants_1.CODEX_SUBAGENTS_PATH);
     if (options.dryRun) {
-        return subagents.map((s) => `Write ${path.join(constants_1.CODEX_SUBAGENTS_PATH, `${s.name}.toml`)}`);
+        return subagents.map((s) => `Write ${path.join(constants_1.CODEX_SUBAGENTS_PATH, withExtension(getSourceRelativeMdPath(s), '.toml'))}`);
     }
     const files = subagents.map((s) => ({
-        name: `${s.name}.toml`,
+        name: withExtension(getSourceRelativeMdPath(s), '.toml'),
         content: buildCodexFile(s),
     }));
     await writeAgentsDirectoryAtomic(targetDir, files);
@@ -325,12 +353,12 @@ async function propagateSubagentsForCopilot(projectRoot, subagents, options) {
             // emits when dryRun is true so users previewing a change can see
             // which tools would be dropped before it actually happens.
             buildCopilotFile(s, true, verbose);
-            planLines.push(`Write ${path.join(constants_1.COPILOT_SUBAGENTS_PATH, `${s.name}.md`)}`);
+            planLines.push(`Write ${path.join(constants_1.COPILOT_SUBAGENTS_PATH, getSourceRelativeMdPath(s))}`);
         }
         return planLines;
     }
     const files = subagents.map((s) => ({
-        name: `${s.name}.md`,
+        name: getSourceRelativeMdPath(s),
         content: buildCopilotFile(s, false, verbose).content,
     }));
     await writeAgentsDirectoryAtomic(targetDir, files);
@@ -363,10 +391,24 @@ async function cleanupAllSubagentsDirectories(projectRoot, dryRun, verbose) {
 /* ------------------------------------------------------------------ */
 /* Orchestrator                                                        */
 /* ------------------------------------------------------------------ */
-async function propagateSubagents(projectRoot, agents, subagentsEnabled, verbose, dryRun) {
-    if (!subagentsEnabled) {
-        (0, constants_1.logVerboseInfo)('Subagents support disabled, cleaning up subagent directories', verbose, dryRun);
+async function propagateSubagents(projectRoot, agents, subagentsEnabled, cleanupOrphaned, verbose, dryRun) {
+    const maybeCleanupAllSubagentsDirectories = async () => {
+        if (!cleanupOrphaned) {
+            (0, constants_1.logVerboseInfo)('Subagent cleanup skipped (set [agents] cleanup_orphaned = true to enable directory cleanup)', verbose, dryRun);
+            return;
+        }
         await cleanupAllSubagentsDirectories(projectRoot, dryRun, verbose);
+    };
+    const maybeCleanupSubagentsDir = async (relPath) => {
+        if (!cleanupOrphaned)
+            return;
+        await cleanupSubagentsDir(projectRoot, relPath, dryRun, verbose);
+    };
+    if (!subagentsEnabled) {
+        (0, constants_1.logVerboseInfo)(cleanupOrphaned
+            ? 'Subagents support disabled, cleaning up subagent directories'
+            : 'Subagents support disabled, leaving existing subagent directories unchanged', verbose, dryRun);
+        await maybeCleanupAllSubagentsDirectories();
         return;
     }
     const sourceDir = path.join(projectRoot, constants_1.RULER_SUBAGENTS_PATH);
@@ -374,16 +416,20 @@ async function propagateSubagents(projectRoot, agents, subagentsEnabled, verbose
         await fs.access(sourceDir);
     }
     catch {
-        (0, constants_1.logVerboseInfo)('No .ruler/agents directory found, cleaning up any stale managed subagent directories', verbose, dryRun);
-        await cleanupAllSubagentsDirectories(projectRoot, dryRun, verbose);
+        (0, constants_1.logVerboseInfo)(cleanupOrphaned
+            ? 'No .ruler/agents directory found, cleaning up any stale managed subagent directories'
+            : 'No .ruler/agents directory found; leaving existing subagent directories unchanged', verbose, dryRun);
+        await maybeCleanupAllSubagentsDirectories();
         return;
     }
     const { subagents, warnings } = await discoverSubagents(projectRoot);
     for (const w of warnings)
         (0, constants_1.logWarn)(w, dryRun);
     if (subagents.length === 0) {
-        (0, constants_1.logVerboseInfo)('No valid subagents found in .ruler/agents; cleaning up any stale managed subagent directories', verbose, dryRun);
-        await cleanupAllSubagentsDirectories(projectRoot, dryRun, verbose);
+        (0, constants_1.logVerboseInfo)(cleanupOrphaned
+            ? 'No valid subagents found in .ruler/agents; cleaning up any stale managed subagent directories'
+            : 'No valid subagents found in .ruler/agents; leaving existing subagent directories unchanged', verbose, dryRun);
+        await maybeCleanupAllSubagentsDirectories();
         return;
     }
     (0, constants_1.logVerboseInfo)(`Discovered ${subagents.length} subagent(s)`, verbose, dryRun);
@@ -401,7 +447,7 @@ async function propagateSubagents(projectRoot, agents, subagentsEnabled, verbose
     const allTargets = ['claude', 'cursor', 'codex', 'copilot'];
     for (const target of allTargets) {
         if (!targets.has(target)) {
-            await cleanupSubagentsDir(projectRoot, SUBAGENT_TARGET_PATHS[target], dryRun, verbose);
+            await maybeCleanupSubagentsDir(SUBAGENT_TARGET_PATHS[target]);
         }
     }
     if (supporting.length === 0) {

package/dist/core/SubagentsUtils.d.ts

@@ -0,0 +1,34 @@
+import type { SubagentFrontmatter, SubagentInfo } from '../types';
+export interface ParsedFrontmatter {
+    meta: Record<string, unknown>;
+    body: string;
+}
+/**
+ * Extracts YAML frontmatter and body from a Markdown file's contents.
+ * Returns null if no frontmatter delimiter pair is present at the head of the file.
+ */
+export declare function parseFrontmatter(content: string): ParsedFrontmatter | null;
+/**
+ * Validates a parsed frontmatter object and reads the required and optional
+ * fields into a typed SubagentFrontmatter. Returns the typed value on success
+ * or an error message on failure.
+ */
+export declare function validateFrontmatter(meta: Record<string, unknown>, expectedName: string): {
+    value: SubagentFrontmatter;
+} | {
+    error: string;
+};
+/**
+ * Loads a single subagent file and produces a SubagentInfo.
+ * Invalid files produce a SubagentInfo with valid=false and an error string.
+ */
+export declare function loadSubagentFile(filePath: string): Promise<SubagentInfo>;
+export interface CopilotToolMapping {
+    tools: string[];
+    unknown: string[];
+}
+/**
+ * Translates Claude tool names to Copilot aliases. Deduplicates results.
+ * Unknown source tools are reported separately so callers can surface a warning.
+ */
+export declare function mapToolsForCopilot(sourceTools: string[]): CopilotToolMapping;

package/dist/core/UnifiedConfigLoader.d.ts

@@ -0,0 +1,10 @@
+import { RulerUnifiedConfig } from './UnifiedConfigTypes';
+export interface UnifiedLoadOptions {
+    projectRoot: string;
+    configPath?: string;
+    cliAgents?: string[];
+    cliMcpEnabled?: boolean;
+    cliMcpStrategy?: string;
+    checkGlobal?: boolean;
+}
+export declare function loadUnifiedConfig(options: UnifiedLoadOptions): Promise<RulerUnifiedConfig>;

package/dist/core/UnifiedConfigLoader.js

@@ -42,8 +42,7 @@ const RuleProcessor_1 = require("./RuleProcessor");
 const FileSystemUtils = __importStar(require("./FileSystemUtils"));
 async function loadUnifiedConfig(options) {
     // Resolve the effective .ruler directory (local or global), mirroring the main loader behavior
-    const resolvedRulerDir = (await FileSystemUtils.findRulerDir(options.projectRoot, true)) ||
-        path.join(options.projectRoot, '.ruler');
+    const resolvedRulerDir = (await FileSystemUtils.findRulerDir(options.projectRoot, options.checkGlobal ?? true)) || path.join(options.projectRoot, '.ruler');
     const meta = {
         projectRoot: options.projectRoot,
         rulerDir: resolvedRulerDir,
@@ -62,11 +61,14 @@ async function loadUnifiedConfig(options) {
         meta.configFile = tomlFile;
     }
     catch (err) {
-        if (err.code !== 'ENOENT') {
+        if (options.configPath ||
+            err.code !== 'ENOENT') {
             diagnostics.push({
-                severity: 'warning',
+                severity: options.configPath ? 'error' : 'warning',
                 code: 'TOML_READ_ERROR',
-                message: 'Failed to read ruler.toml',
+                message: options.configPath
+                    ? 'Failed to read explicit config file'
+                    : 'Failed to read ruler.toml',
                 file: tomlFile,
                 detail: err.message,
             });
@@ -104,37 +106,41 @@ async function loadUnifiedConfig(options) {
         nested,
         skills: skillsConfig,
     };
+    const includeAgentsInRules = (() => {
+        if (!tomlRaw || typeof tomlRaw !== 'object')
+            return false;
+        const raw = tomlRaw;
+        const agents = raw.agents;
+        const subagents = raw.subagents;
+        return ((agents &&
+            typeof agents === 'object' &&
+            agents.include_in_rules === true) ||
+            (subagents &&
+                typeof subagents === 'object' &&
+                subagents.include_in_rules === true));
+    })();
     // Collect rule markdown files
     let ruleFiles = [];
     try {
-        const dirEntries = await fs_1.promises.readdir(meta.rulerDir, { withFileTypes: true });
-        const mdFiles = dirEntries
-            .filter((e) => e.isFile() && e.name.toLowerCase().endsWith('.md'))
-            .map((e) => path.join(meta.rulerDir, e.name));
-        // Sort lexicographically then ensure AGENTS.md first
-        mdFiles.sort((a, b) => a.localeCompare(b));
-        mdFiles.sort((a, b) => {
-            const aIs = /agents\.md$/i.test(a);
-            const bIs = /agents\.md$/i.test(b);
-            if (aIs && !bIs)
-                return -1;
-            if (bIs && !aIs)
-                return 1;
-            return 0;
+        const mdFiles = await FileSystemUtils.readMarkdownFiles(meta.rulerDir, {
+            includeAgents: includeAgentsInRules,
         });
         let order = 0;
         ruleFiles = await Promise.all(mdFiles.map(async (file) => {
-            const content = await fs_1.promises.readFile(file, 'utf8');
-            const stat = await fs_1.promises.stat(file);
+            const stat = await fs_1.promises.stat(file.path);
+            const relativeFromRuler = path.relative(meta.rulerDir, file.path);
+            const relativePath = relativeFromRuler.startsWith('..')
+                ? path.relative(path.dirname(meta.rulerDir), file.path)
+                : relativeFromRuler;
             return {
-                path: file,
-                relativePath: path.basename(file),
-                content,
-                contentHash: (0, hash_1.sha256)(content),
+                path: file.path,
+                relativePath: relativePath.replace(/\\/g, '/'),
+                content: file.content,
+                contentHash: (0, hash_1.sha256)(file.content),
                 mtimeMs: stat.mtimeMs,
                 size: stat.size,
                 order: order++,
-                primary: /agents\.md$/i.test(file),
+                primary: /(^|[/\\])agents\.md$/i.test(relativePath),
             };
         }));
     }
@@ -221,6 +227,11 @@ async function loadUnifiedConfig(options) {
                         file: tomlFile,
                     });
                 }
+                if (hasCommand && hasUrl) {
+                    delete server.command;
+                    delete server.args;
+                    delete server.env;
+                }
                 // Derive type - remote takes precedence if both are present
                 if (server.url) {
                     server.type = 'remote';
@@ -282,13 +293,32 @@ async function loadUnifiedConfig(options) {
                 }
             }
             const parsedObj = parsed;
-            const serversRaw = parsedObj.mcpServers ||
-                parsedObj.servers ||
-                {};
-            if (serversRaw && typeof serversRaw === 'object') {
+            const serversRaw = 'mcpServers' in parsedObj
+                ? parsedObj.mcpServers
+                : 'servers' in parsedObj
+                    ? parsedObj.servers
+                    : undefined;
+            if (!serversRaw ||
+                typeof serversRaw !== 'object' ||
+                Array.isArray(serversRaw)) {
+                diagnostics.push({
+                    severity: 'warning',
+                    code: 'MCP_INVALID_SHAPE',
+                    message: 'mcp.json must contain a non-array object in "mcpServers" or "servers"',
+                    file: mcpFile,
+                });
+            }
+            else {
                 for (const [name, def] of Object.entries(serversRaw)) {
-                    if (!def || typeof def !== 'object')
+                    if (!def || typeof def !== 'object' || Array.isArray(def)) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_INVALID_SERVER',
+                            message: `MCP server '${name}' must be an object`,
+                            file: mcpFile,
+                        });
                         continue;
+                    }
                     const server = {};
                     if (typeof def.command === 'string')
                         server.command = def.command;

package/dist/core/UnifiedConfigTypes.d.ts

@@ -0,0 +1,95 @@
+import { McpConfig, GitignoreConfig, SkillsConfig, SubagentsConfig, McpStrategy } from '../types';
+export interface RulerUnifiedConfig {
+    meta: ConfigMeta;
+    toml: TomlConfig;
+    rules: RulesBundle;
+    mcp: McpBundle | null;
+    agents: Record<string, EffectiveAgentConfig>;
+    diagnostics: ConfigDiagnostic[];
+    hash: string;
+}
+export interface ConfigMeta {
+    projectRoot: string;
+    rulerDir: string;
+    configFile?: string;
+    mcpFile?: string;
+    loadedAt: Date;
+    version: string;
+}
+export interface TomlConfig {
+    raw: unknown;
+    schemaVersion: number;
+    defaultAgents?: string[];
+    agents: Record<string, AgentTomlConfig>;
+    mcp?: McpToggleConfig;
+    mcpServers?: Record<string, McpServerDef>;
+    gitignore?: GitignoreConfig;
+    skills?: SkillsConfig;
+    subagents?: SubagentsConfig;
+    nested?: boolean;
+}
+export type McpToggleConfig = McpConfig;
+export interface AgentTomlConfig {
+    enabled?: boolean;
+    outputPath?: string;
+    outputPathInstructions?: string;
+    outputPathConfig?: string;
+    mcp?: McpConfig;
+    source: AgentConfigSourceMeta;
+}
+export interface AgentConfigSourceMeta {
+    sectionPath: string;
+}
+export interface RulesBundle {
+    files: RuleFile[];
+    concatenated: string;
+    concatenatedHash: string;
+}
+export interface RuleFile {
+    path: string;
+    relativePath: string;
+    content: string;
+    contentHash: string;
+    mtimeMs: number;
+    size: number;
+    order: number;
+    primary: boolean;
+}
+export interface McpBundle {
+    servers: Record<string, McpServerDef>;
+    raw: Record<string, unknown>;
+    hash: string;
+}
+export interface McpServerDef {
+    type?: 'stdio' | 'local' | 'remote';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export interface EffectiveAgentConfig {
+    identifier: string;
+    enabled: boolean;
+    output: AgentOutputPaths;
+    mcp: EffectiveMcpConfig;
+    toml?: AgentTomlConfig;
+}
+export interface AgentOutputPaths {
+    instructions?: string;
+    config?: string;
+    generic?: string;
+}
+export interface EffectiveMcpConfig {
+    enabled: boolean;
+    strategy: McpStrategy;
+}
+export type DiagnosticSeverity = 'info' | 'warning' | 'error';
+export interface ConfigDiagnostic {
+    severity: DiagnosticSeverity;
+    code: string;
+    message: string;
+    file?: string;
+    detail?: string;
+}

package/dist/core/agent-selection.d.ts

@@ -0,0 +1,12 @@
+import { IAgent } from '../agents/IAgent';
+import { LoadedConfig } from './ConfigLoader';
+export declare function agentMatchesFilter(agent: IAgent, filter: string, validAgentIdentifiers: Set<string>): boolean;
+/**
+ * Resolves which agents should be selected based on configuration.
+ * Handles precedence: CLI agents > default_agents > per-agent enabled flags > all agents
+ *
+ * @param config Loaded configuration containing CLI agents, default agents, and per-agent configs
+ * @param allAgents Array of all available agents
+ * @returns Array of agents that should be processed
+ */
+export declare function resolveSelectedAgents(config: LoadedConfig, allAgents: IAgent[]): IAgent[];

package/dist/core/agent-selection.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentMatchesFilter = agentMatchesFilter;
 exports.resolveSelectedAgents = resolveSelectedAgents;
 const constants_1 = require("../constants");
+function agentMatchesFilter(agent, filter, validAgentIdentifiers) {
+    const identifier = agent.getIdentifier().toLowerCase();
+    // Exact identifier matches take precedence over fuzzy display-name matching.
+    if (validAgentIdentifiers.has(filter)) {
+        return identifier === filter;
+    }
+    return agent.getName().toLowerCase().includes(filter);
+}
 /**
  * Resolves which agents should be selected based on configuration.
  * Handles precedence: CLI agents > default_agents > per-agent enabled flags > all agents
@@ -23,8 +32,7 @@ function resolveSelectedAgents(config, allAgents) {
         if (invalidAgents.length > 0) {
             throw (0, constants_1.createRulerError)(`Invalid agent specified: ${invalidAgents.join(', ')}`, `Valid agents are: ${[...validAgentIdentifiers].join(', ')}`);
         }
-        selected = allAgents.filter((agent) => filters.some((f) => agent.getIdentifier() === f ||
-            agent.getName().toLowerCase().includes(f)));
+        selected = allAgents.filter((agent) => filters.some((f) => agentMatchesFilter(agent, f, validAgentIdentifiers)));
     }
     else if (config.defaultAgents && config.defaultAgents.length > 0) {
         const defaults = config.defaultAgents.map((n) => n.toLowerCase());
@@ -42,7 +50,7 @@ function resolveSelectedAgents(config, allAgents) {
             if (override !== undefined) {
                 return override;
             }
-            return defaults.some((d) => identifier === d || agent.getName().toLowerCase().includes(d));
+            return defaults.some((d) => agentMatchesFilter(agent, d, validAgentIdentifiers));
         });
     }
     else {

package/dist/core/apply-engine.d.ts

@@ -0,0 +1,69 @@
+import { LoadedConfig } from './ConfigLoader';
+import { IAgent } from '../agents/IAgent';
+import { McpStrategy } from '../types';
+/**
+ * Configuration data loaded from the ruler setup
+ */
+export interface RulerConfiguration {
+    config: LoadedConfig;
+    concatenatedRules: string;
+    rulerMcpJson: Record<string, unknown> | null;
+}
+/**
+ * Configuration data for a specific .ruler directory in hierarchical mode
+ */
+export interface HierarchicalRulerConfiguration extends RulerConfiguration {
+    rulerDir: string;
+}
+export declare function loadNestedConfigurations(projectRoot: string, configPath: string | undefined, localOnly: boolean, resolvedNested: boolean): Promise<HierarchicalRulerConfiguration[]>;
+/**
+ * Loads configuration for single-directory mode (existing behavior).
+ */
+export declare function loadSingleConfiguration(projectRoot: string, configPath: string | undefined, localOnly: boolean): Promise<RulerConfiguration>;
+/**
+ * Processes hierarchical configurations by applying rules to each .ruler directory independently.
+ * Each directory gets its own set of rules and generates its own agent files.
+ * @param agents Array of agents to process
+ * @param configurations Array of hierarchical configurations for each .ruler directory
+ * @param verbose Whether to enable verbose logging
+ * @param dryRun Whether to perform a dry run
+ * @param cliMcpEnabled Whether MCP is enabled via CLI
+ * @param cliMcpStrategy MCP strategy from CLI
+ * @returns Promise resolving to array of generated file paths
+ */
+export declare function processHierarchicalConfigurations(agents: IAgent[], configurations: HierarchicalRulerConfiguration[], verbose: boolean, dryRun: boolean, cliMcpEnabled: boolean, cliMcpStrategy?: McpStrategy, backup?: boolean): Promise<string[]>;
+/**
+ * Processes a single configuration by applying rules to all selected agents.
+ * All rules are concatenated and applied to generate agent files in the project root.
+ * @param agents Array of agents to process
+ * @param configuration Single ruler configuration with concatenated rules
+ * @param projectRoot Root directory of the project
+ * @param verbose Whether to enable verbose logging
+ * @param dryRun Whether to perform a dry run
+ * @param cliMcpEnabled Whether MCP is enabled via CLI
+ * @param cliMcpStrategy MCP strategy from CLI
+ * @returns Promise resolving to array of generated file paths
+ */
+export declare function processSingleConfiguration(agents: IAgent[], configuration: RulerConfiguration, projectRoot: string, verbose: boolean, dryRun: boolean, cliMcpEnabled: boolean, cliMcpStrategy?: McpStrategy, backup?: boolean): Promise<string[]>;
+/**
+ * Applies configurations to the selected agents (internal function).
+ * @param agents Array of agents to process
+ * @param concatenatedRules Concatenated rule content
+ * @param rulerMcpJson MCP configuration JSON
+ * @param config Loaded configuration
+ * @param projectRoot Root directory of the project
+ * @param verbose Whether to enable verbose logging
+ * @param dryRun Whether to perform a dry run
+ * @returns Promise resolving to array of generated file paths
+ */
+export declare function applyConfigurationsToAgents(agents: IAgent[], concatenatedRules: string, rulerMcpJson: Record<string, unknown> | null, config: LoadedConfig, projectRoot: string, verbose: boolean, dryRun: boolean, cliMcpEnabled?: boolean, cliMcpStrategy?: McpStrategy, backup?: boolean): Promise<string[]>;
+/**
+ * Updates the .gitignore file with generated paths.
+ * @param projectRoot Root directory of the project
+ * @param generatedPaths Array of generated file paths
+ * @param config Loaded configuration
+ * @param cliGitignoreEnabled CLI gitignore setting
+ * @param dryRun Whether to perform a dry run
+ * @param cliGitignoreLocal CLI toggle for .git/info/exclude usage
+ */
+export declare function updateGitignore(projectRoot: string, generatedPaths: string[], config: LoadedConfig, cliGitignoreEnabled: boolean | undefined, dryRun: boolean, cliGitignoreLocal?: boolean): Promise<void>;