@intellectronica/ruler 0.3.41 → 0.3.43

package/dist/core/apply-engine.js

@@ -52,6 +52,7 @@ const propagateOpenHandsMcp_1 = require("../mcp/propagateOpenHandsMcp");
 const propagateOpenCodeMcp_1 = require("../mcp/propagateOpenCodeMcp");
 const agent_utils_1 = require("../agents/agent-utils");
 const capabilities_1 = require("../mcp/capabilities");
+const path_utils_1 = require("./path-utils");
 const constants_1 = require("../constants");
 async function loadNestedConfigurations(projectRoot, configPath, localOnly, resolvedNested) {
     const { dirs: rulerDirs } = await findRulerDirectories(projectRoot, localOnly, true);
@@ -59,11 +60,11 @@ async function loadNestedConfigurations(projectRoot, configPath, localOnly, reso
     // Load config first so we know whether `.ruler/agents/` should be included
     // in the rule concatenation for each directory.
     for (const rulerDir of rulerDirs) {
-        const config = await loadConfigForRulerDir(rulerDir, configPath, resolvedNested);
+        const config = await loadConfigForRulerDir(rulerDir, configPath, resolvedNested, localOnly);
         const files = await FileSystemUtils.readMarkdownFiles(rulerDir, {
             includeAgents: shouldIncludeAgentsInRules(config),
         });
-        results.push(await createHierarchicalConfiguration(rulerDir, files, config, configPath));
+        results.push(await createHierarchicalConfiguration(rulerDir, files, config, configPath, localOnly));
     }
     return results;
 }
@@ -74,7 +75,7 @@ async function loadNestedConfigurations(projectRoot, configPath, localOnly, reso
 function shouldIncludeAgentsInRules(config) {
     return config.subagents?.include_in_rules === true;
 }
-async function createHierarchicalConfiguration(rulerDir, files, config, cliConfigPath) {
+async function createHierarchicalConfiguration(rulerDir, files, config, cliConfigPath, localOnly) {
     await warnAboutLegacyMcpJson(rulerDir);
     const concatenatedRules = (0, RuleProcessor_1.concatenateRules)(files, path.dirname(rulerDir));
     const directoryRoot = path.dirname(rulerDir);
@@ -91,6 +92,7 @@ async function createHierarchicalConfiguration(rulerDir, files, config, cliConfi
     const unifiedConfig = await loadUnifiedConfig({
         projectRoot: directoryRoot,
         configPath: configPathToUse,
+        checkGlobal: !localOnly,
     });
     let rulerMcpJson = null;
     if (unifiedConfig.mcp && Object.keys(unifiedConfig.mcp.servers).length > 0) {
@@ -103,9 +105,10 @@ async function createHierarchicalConfiguration(rulerDir, files, config, cliConfi
         config,
         concatenatedRules,
         rulerMcpJson,
+        projectRoot: directoryRoot,
     };
 }
-async function loadConfigForRulerDir(rulerDir, cliConfigPath, resolvedNested) {
+async function loadConfigForRulerDir(rulerDir, cliConfigPath, resolvedNested, localOnly) {
     const directoryRoot = path.dirname(rulerDir);
     const localConfigPath = path.join(rulerDir, 'ruler.toml');
     let hasLocalConfig = false;
@@ -119,6 +122,7 @@ async function loadConfigForRulerDir(rulerDir, cliConfigPath, resolvedNested) {
     const loaded = await (0, ConfigLoader_1.loadConfig)({
         projectRoot: directoryRoot,
         configPath: hasLocalConfig ? localConfigPath : cliConfigPath,
+        checkGlobal: !localOnly,
     });
     const cloned = cloneLoadedConfig(loaded);
     if (resolvedNested) {
@@ -136,6 +140,12 @@ function cloneLoadedConfig(config) {
         clonedAgentConfigs[agent] = {
             ...agentConfig,
             mcp: agentConfig.mcp ? { ...agentConfig.mcp } : undefined,
+            mcpServers: agentConfig.mcpServers
+                ? Object.fromEntries(Object.entries(agentConfig.mcpServers).map(([name, server]) => [
+                    name,
+                    { ...server },
+                ]))
+                : undefined,
         };
     }
     return {
@@ -144,6 +154,7 @@ function cloneLoadedConfig(config) {
         cliAgents: config.cliAgents ? [...config.cliAgents] : undefined,
         mcp: config.mcp ? { ...config.mcp } : undefined,
         gitignore: config.gitignore ? { ...config.gitignore } : undefined,
+        backup: config.backup ? { ...config.backup } : undefined,
         skills: config.skills ? { ...config.skills } : undefined,
         subagents: config.subagents ? { ...config.subagents } : undefined,
         nested: config.nested,
@@ -156,18 +167,10 @@ function cloneLoadedConfig(config) {
 async function findRulerDirectories(projectRoot, localOnly, hierarchical) {
     if (hierarchical) {
         const dirs = await FileSystemUtils.findAllRulerDirs(projectRoot);
-        const allDirs = [...dirs];
-        // Add global config if not local-only
-        if (!localOnly) {
-            const globalDir = await FileSystemUtils.findGlobalRulerDir();
-            if (globalDir) {
-                allDirs.push(globalDir);
-            }
-        }
-        if (allDirs.length === 0) {
+        if (dirs.length === 0) {
             throw (0, constants_1.createRulerError)(`.ruler directory not found`, `Searched from: ${projectRoot}`);
         }
-        return { dirs: allDirs, primaryDir: allDirs[0] };
+        return { dirs, primaryDir: dirs[0] };
     }
     else {
         const dir = await FileSystemUtils.findRulerDir(projectRoot, !localOnly);
@@ -198,10 +201,12 @@ async function loadSingleConfiguration(projectRoot, configPath, localOnly) {
     const { dirs: rulerDirs, primaryDir } = await findRulerDirectories(projectRoot, localOnly, false);
     // Warn about legacy mcp.json
     await warnAboutLegacyMcpJson(primaryDir);
+    const effectiveProjectRoot = FileSystemUtils.resolveProjectRootForRulerDir(projectRoot, primaryDir);
     // Load the ruler.toml configuration
     const config = await (0, ConfigLoader_1.loadConfig)({
-        projectRoot,
+        projectRoot: effectiveProjectRoot,
         configPath,
+        checkGlobal: !localOnly,
     });
     // Read rule files. `.ruler/agents/` is only included when
     // `[agents] include_in_rules = true`.
@@ -212,7 +217,11 @@ async function loadSingleConfiguration(projectRoot, configPath, localOnly) {
     const concatenatedRules = (0, RuleProcessor_1.concatenateRules)(files, path.dirname(primaryDir));
     // Load unified config to get merged MCP configuration
     const { loadUnifiedConfig } = await Promise.resolve().then(() => __importStar(require('./UnifiedConfigLoader')));
-    const unifiedConfig = await loadUnifiedConfig({ projectRoot, configPath });
+    const unifiedConfig = await loadUnifiedConfig({
+        projectRoot: effectiveProjectRoot,
+        configPath,
+        checkGlobal: !localOnly,
+    });
     // Synthesize rulerMcpJson from unified MCP bundle for backward compatibility
     let rulerMcpJson = null;
     if (unifiedConfig.mcp && Object.keys(unifiedConfig.mcp.servers).length > 0) {
@@ -224,6 +233,7 @@ async function loadSingleConfiguration(projectRoot, configPath, localOnly) {
         config,
         concatenatedRules,
         rulerMcpJson,
+        projectRoot: effectiveProjectRoot,
     };
 }
 /**
@@ -281,7 +291,7 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
         (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 = rulerMcpJson;
+        const agentRulerMcpJson = mergeAgentMcpServers(rulerMcpJson, agentConfig);
         // 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);
@@ -306,22 +316,27 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                     agentsMdWritten = true;
                 }
             }
-            let finalAgentConfig = agentConfig;
-            if (agent.getIdentifier() === 'augmentcode' && agentRulerMcpJson) {
-                const resolvedStrategy = cliMcpStrategy ??
-                    agentConfig?.mcp?.strategy ??
-                    config.mcp?.strategy ??
-                    'merge';
-                finalAgentConfig = {
-                    ...agentConfig,
-                    mcp: {
-                        ...agentConfig?.mcp,
-                        strategy: resolvedStrategy,
-                    },
-                };
-            }
+            const effectiveMcpEnabled = cliMcpEnabled &&
+                (agentConfig?.mcp?.enabled ?? config.mcp?.enabled ?? true);
+            const effectiveMcpStrategy = cliMcpStrategy ??
+                agentConfig?.mcp?.strategy ??
+                config.mcp?.strategy ??
+                'merge';
+            const finalAgentConfig = {
+                ...agentConfig,
+                mcp: {
+                    ...agentConfig?.mcp,
+                    enabled: effectiveMcpEnabled,
+                    strategy: effectiveMcpStrategy,
+                },
+            };
+            const mcpForAgentApply = shouldUseEngineManagedMcp(agent)
+                ? null
+                : effectiveMcpEnabled
+                    ? agentRulerMcpJson
+                    : null;
             if (!skipApplyForThisAgent) {
-                await agent.applyRulerConfig(concatenatedRules, projectRoot, agentRulerMcpJson, finalAgentConfig, backup);
+                await agent.applyRulerConfig(concatenatedRules, projectRoot, mcpForAgentApply, finalAgentConfig, backup);
             }
         }
         // Handle MCP configuration
@@ -334,7 +349,7 @@ async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson,
         (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 dest = await resolveMcpDestination(agent, agentConfig, projectRoot);
     const mcpEnabledForAgent = cliMcpEnabled && (agentConfig?.mcp?.enabled ?? config.mcp?.enabled ?? true);
     if (!dest || !mcpEnabledForAgent) {
         return;
@@ -349,8 +364,30 @@ async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson,
     await updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup);
     await applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup);
 }
+function shouldUseEngineManagedMcp(agent) {
+    return (agent.getIdentifier() === 'codex' || agent.getIdentifier() === 'opencode');
+}
+function mergeAgentMcpServers(rulerMcpJson, agentConfig) {
+    const baseServers = rulerMcpJson?.mcpServers && typeof rulerMcpJson.mcpServers === 'object'
+        ? rulerMcpJson.mcpServers
+        : {};
+    const agentServers = agentConfig?.mcpServers ?? {};
+    const mergedServers = {
+        ...baseServers,
+        ...agentServers,
+    };
+    return Object.keys(mergedServers).length > 0
+        ? { mcpServers: mergedServers }
+        : null;
+}
+async function resolveMcpDestination(agent, agentConfig, projectRoot) {
+    if (agentConfig?.outputPathConfig) {
+        return path.resolve(projectRoot, agentConfig.outputPathConfig);
+    }
+    return await (0, mcp_1.getNativeMcpPath)(agent.getName(), projectRoot);
+}
 async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup = true) {
-    if (dest.startsWith(projectRoot)) {
+    if ((0, path_utils_1.isPathInsideOrEqual)(projectRoot, dest)) {
         const relativeDest = path.relative(projectRoot, dest);
         generatedPaths.push(relativeDest);
         if (backup) {
@@ -391,16 +428,16 @@ function sanitizeMcpTimeoutsForAgent(agent, mcpJson, dryRun) {
 }
 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)) {
+    if (!(0, path_utils_1.isPathInsideOrEqual)(projectRoot, dest)) {
         (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(agentMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenHandsMcpConfiguration(agentMcpJson, dest, projectRoot, cliMcpStrategy ?? agentConfig?.mcp?.strategy ?? config.mcp?.strategy, dryRun, verbose, backup);
     }
     if (agent.getIdentifier() === 'opencode') {
-        return await applyOpenCodeMcpConfiguration(agentMcpJson, dest, dryRun, verbose, backup);
+        return await applyOpenCodeMcpConfiguration(agentMcpJson, dest, projectRoot, cliMcpStrategy ?? agentConfig?.mcp?.strategy ?? config.mcp?.strategy, dryRun, verbose, backup);
     }
     // Agents that handle MCP configuration internally should not have external MCP handling
     if (agent.getIdentifier() === 'zed' ||
@@ -410,22 +447,22 @@ 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, agentMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
+    return await applyStandardMcpConfiguration(agent, agentMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup);
 }
-async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
+async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, projectRoot, strategy, 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, backup);
+        await (0, propagateOpenHandsMcp_1.propagateMcpToOpenHands)(filteredMcpJson, dest, backup, strategy, projectRoot);
     }
 }
-async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup = true) {
+async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, projectRoot, strategy, 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, backup);
+        await (0, propagateOpenCodeMcp_1.propagateMcpToOpenCode)(filteredMcpJson, dest, backup, strategy, projectRoot);
     }
 }
 /**
@@ -521,7 +558,7 @@ function transformMcpForFactoryDroid(mcpJson) {
     transformedMcp.mcpServers = transformedServers;
     return transformedMcp;
 }
-async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup = true) {
+async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup = true) {
     const strategy = cliMcpStrategy ??
         agentConfig?.mcp?.strategy ??
         config.mcp?.strategy ??
@@ -539,7 +576,8 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
     else {
         // Transform MCP config for agent-specific compatibility
         let mcpToMerge = filteredMcpJson;
-        if (agent.getIdentifier() === 'claude') {
+        if (agent.getIdentifier() === 'claude' ||
+            agent.getIdentifier() === 'aider') {
             mcpToMerge = transformMcpForClaude(filteredMcpJson);
         }
         else if (agent.getIdentifier() === 'kilocode') {
@@ -550,17 +588,9 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         }
         const CODEX_AGENT_ID = 'codex';
         const isCodexToml = agent.getIdentifier() === CODEX_AGENT_ID && dest.endsWith('.toml');
-        let existing = await (0, mcp_1.readNativeMcp)(dest);
-        if (isCodexToml) {
-            try {
-                const tomlContent = await fs_1.promises.readFile(dest, 'utf8');
-                existing = (0, toml_1.parse)(tomlContent);
-            }
-            catch (error) {
-                (0, constants_1.logVerbose)(`Failed to read Codex MCP TOML at ${dest}: ${error.message}`, verbose);
-                // ignore missing or invalid TOML, fall back to previously read value
-            }
-        }
+        const existing = isCodexToml
+            ? await (0, mcp_1.readNativeMcpToml)(dest, (text) => (0, toml_1.parse)(text))
+            : await (0, mcp_1.readNativeMcp)(dest);
         let merged = (0, merge_1.mergeMcp)(existing, mcpToMerge, strategy, serverKey);
         if (isCodexToml) {
             const { [serverKey]: servers, ...rest } = merged;
@@ -626,13 +656,13 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         if (currentContent !== newContent) {
             if (backup) {
                 const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
-                await backupFile(dest);
+                await backupFile(dest, projectRoot);
             }
             if (isCodexToml) {
-                await FileSystemUtils.writeGeneratedFile(dest, (0, toml_1.stringify)(toWrite));
+                await FileSystemUtils.writeGeneratedFile(dest, (0, toml_1.stringify)(toWrite), projectRoot);
             }
             else {
-                await (0, mcp_1.writeNativeMcp)(dest, toWrite);
+                await (0, mcp_1.writeNativeMcp)(dest, toWrite, projectRoot);
             }
         }
         else {

package/dist/core/config-utils.d.ts

@@ -0,0 +1,14 @@
+import { IAgent, IAgentConfig } from '../agents/IAgent';
+/**
+ * Maps raw agent configuration keys to their corresponding agent identifiers.
+ *
+ * This function normalizes configuration keys by matching them against agent identifiers
+ * and display names. It performs both exact matching (case-insensitive) with agent
+ * identifiers and substring matching (case-insensitive) with agent display names
+ * for backwards compatibility.
+ *
+ * @param raw Raw agent configurations with user-provided keys
+ * @param agents Array of all available agents
+ * @returns Record with agent identifiers as keys and their configurations as values
+ */
+export declare function mapRawAgentConfigs(raw: Record<string, IAgentConfig>, agents: IAgent[]): Record<string, IAgentConfig>;

package/dist/core/config-utils.js

@@ -17,11 +17,17 @@ function mapRawAgentConfigs(raw, agents) {
     const mappedConfigs = {};
     for (const [key, cfg] of Object.entries(raw)) {
         const lowerKey = key.toLowerCase();
+        const exactMatches = agents.filter((agent) => agent.getIdentifier().toLowerCase() === lowerKey);
+        // Exact identifier matches take precedence over fuzzy display-name matching.
+        if (exactMatches.length > 0) {
+            for (const agent of exactMatches) {
+                mappedConfigs[agent.getIdentifier()] = cfg;
+            }
+            continue;
+        }
         for (const agent of agents) {
             const identifier = agent.getIdentifier();
-            // Exact match with identifier or substring match with display name for backwards compatibility
-            if (identifier === lowerKey ||
-                agent.getName().toLowerCase().includes(lowerKey)) {
+            if (agent.getName().toLowerCase().includes(lowerKey)) {
                 mappedConfigs[identifier] = cfg;
             }
         }

package/dist/core/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function sha256(data: string): string;
+export declare function stableJson(value: unknown): string;

package/dist/core/path-utils.d.ts

@@ -0,0 +1 @@
+export declare function isPathInsideOrEqual(parentPath: string, targetPath: string): boolean;

package/dist/core/path-utils.js

@@ -0,0 +1,42 @@
+"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.isPathInsideOrEqual = isPathInsideOrEqual;
+const path = __importStar(require("path"));
+function isPathInsideOrEqual(parentPath, targetPath) {
+    const relative = path.relative(path.resolve(parentPath), path.resolve(targetPath));
+    return (relative === '' ||
+        (!relative.startsWith('..') && !path.isAbsolute(relative)));
+}

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

@@ -0,0 +1,37 @@
+import { IAgent } from '../agents/IAgent';
+import { IAgentConfig } from './ConfigLoader';
+/**
+ * Result of reverting an agent configuration
+ */
+export interface RevertAgentResult {
+    restored: number;
+    removed: number;
+    backupsRemoved: number;
+}
+/**
+ * Result of cleaning up auxiliary files
+ */
+export interface CleanUpResult {
+    additionalFilesRemoved: number;
+    directoriesRemoved: number;
+}
+/**
+ * Reverts configuration for a single agent.
+ * @param agent The agent to revert
+ * @param projectRoot Root directory of the project
+ * @param agentConfig Agent-specific configuration
+ * @param keepBackups Whether restored backup files should be preserved
+ * @param verbose Whether to enable verbose logging
+ * @param dryRun Whether to perform a dry run
+ * @returns Promise resolving to revert statistics
+ */
+export declare function revertAgentConfiguration(agent: IAgent, projectRoot: string, agentConfig: IAgentConfig | undefined, keepBackups: boolean, verbose: boolean, dryRun: boolean): Promise<RevertAgentResult>;
+/**
+ * Cleans up auxiliary files and directories.
+ * @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 cleanup statistics
+ */
+export declare function cleanUpAuxiliaryFiles(projectRoot: string, verbose: boolean, dryRun: boolean): Promise<CleanUpResult>;
+export declare function cleanUpAgentDirectories(agent: IAgent, projectRoot: string, agentConfig: IAgentConfig | undefined, verbose: boolean, dryRun: boolean): Promise<number>;