@intellectronica/ruler 0.3.41 → 0.3.43

package/dist/core/SubagentsProcessor.js

@@ -48,6 +48,7 @@ const yaml = __importStar(require("js-yaml"));
 const toml_1 = require("@iarna/toml");
 const constants_1 = require("../constants");
 const SubagentsUtils_1 = require("./SubagentsUtils");
+const FileSystemUtils_1 = require("./FileSystemUtils");
 /**
  * Discovers subagent definitions in `.ruler/agents/`.
  * Each `.md` file is parsed for YAML frontmatter (name, description, …).
@@ -173,8 +174,9 @@ function ensureBodyFormatting(body) {
  * Stages files into a temp directory and atomically swaps it into place.
  * Mirrors the pattern used by SkillsProcessor for safe overwriting.
  */
-async function writeAgentsDirectoryAtomic(targetDir, files) {
+async function writeAgentsDirectoryAtomic(targetDir, files, projectRoot) {
     const parent = path.dirname(targetDir);
+    await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(targetDir, projectRoot, 'Refusing to replace subagents directory through symlinked path');
     await fs.mkdir(parent, { recursive: true });
     const tempDir = path.join(parent, `agents.tmp-${Date.now()}`);
     await fs.mkdir(tempDir, { recursive: true });
@@ -310,7 +312,7 @@ async function propagateSubagentsForClaude(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildClaudeFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCursor(projectRoot, subagents, options) {
@@ -324,7 +326,7 @@ async function propagateSubagentsForCursor(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildCursorFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCodex(projectRoot, subagents, options) {
@@ -338,7 +340,7 @@ async function propagateSubagentsForCodex(projectRoot, subagents, options) {
         name: withExtension(getSourceRelativeMdPath(s), '.toml'),
         content: buildCodexFile(s),
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 async function propagateSubagentsForCopilot(projectRoot, subagents, options) {
@@ -361,7 +363,7 @@ async function propagateSubagentsForCopilot(projectRoot, subagents, options) {
         name: getSourceRelativeMdPath(s),
         content: buildCopilotFile(s, false, verbose).content,
     }));
-    await writeAgentsDirectoryAtomic(targetDir, files);
+    await writeAgentsDirectoryAtomic(targetDir, files, projectRoot);
     return [];
 }
 /* ------------------------------------------------------------------ */
@@ -379,6 +381,7 @@ async function cleanupSubagentsDir(projectRoot, relPath, dryRun, verbose) {
         (0, constants_1.logVerboseInfo)(`DRY RUN: Would remove ${relPath}`, verbose, dryRun);
         return;
     }
+    await (0, FileSystemUtils_1.assertManagedPathInsideRoot)(target, projectRoot, 'Refusing to remove subagents directory through symlinked path');
     await fs.rm(target, { recursive: true, force: true });
     (0, constants_1.logVerboseInfo)(`Removed ${relPath} (subagents disabled)`, verbose, dryRun);
 }

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

@@ -40,10 +40,21 @@ const toml_1 = require("@iarna/toml");
 const hash_1 = require("./hash");
 const RuleProcessor_1 = require("./RuleProcessor");
 const FileSystemUtils = __importStar(require("./FileSystemUtils"));
+const KNOWN_MCP_SERVER_FIELDS = new Set([
+    'type',
+    'command',
+    'args',
+    'env',
+    'url',
+    'headers',
+    'timeout',
+]);
+function copyAdditionalMcpServerFields(def) {
+    return Object.fromEntries(Object.entries(def).filter(([key]) => !KNOWN_MCP_SERVER_FIELDS.has(key)));
+}
 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 +73,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 +118,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),
             };
         }));
     }
@@ -163,7 +181,7 @@ async function loadUnifiedConfig(options) {
                 if (!def || typeof def !== 'object')
                     continue;
                 const serverDef = def;
-                const server = {};
+                const server = copyAdditionalMcpServerFields(serverDef);
                 // Parse command and args
                 if (typeof serverDef.command === 'string') {
                     server.command = serverDef.command;
@@ -221,6 +239,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,14 +305,33 @@ 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 = {};
+                    }
+                    const server = copyAdditionalMcpServerFields(def);
                     if (typeof def.command === 'string')
                         server.command = def.command;
                     if (Array.isArray(def.command))
@@ -307,6 +349,46 @@ async function loadUnifiedConfig(options) {
                     if (typeof def.timeout === 'number') {
                         server.timeout = def.timeout;
                     }
+                    const hasCommand = !!server.command;
+                    const hasUrl = !!server.url;
+                    if (!hasCommand && !hasUrl) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_INVALID_SERVER',
+                            message: `MCP server '${name}' must have at least one of command or url`,
+                            file: mcpFile,
+                        });
+                        continue;
+                    }
+                    if (hasCommand && hasUrl) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has both command and url - using url (remote)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasCommand && server.headers) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has headers with command (should be used with url only)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasUrl && server.env) {
+                        diagnostics.push({
+                            severity: 'warning',
+                            code: 'MCP_JSON_FIELD_CONFLICT',
+                            message: `MCP server '${name}' has env with url (should be used with command only)`,
+                            file: mcpFile,
+                        });
+                    }
+                    if (hasCommand && hasUrl) {
+                        delete server.command;
+                        delete server.args;
+                        delete server.env;
+                    }
                     // Derive type
                     if (server.url)
                         server.type = 'remote';

package/dist/core/UnifiedConfigTypes.d.ts

@@ -0,0 +1,97 @@
+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;
+    mcpServers?: Record<string, McpServerDef>;
+    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 {
+    [key: string]: unknown;
+    type?: string;
+    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
@@ -13,24 +22,25 @@ const constants_1 = require("../constants");
 function resolveSelectedAgents(config, allAgents) {
     // CLI --agents > config.default_agents > per-agent.enabled flags > default all
     let selected = allAgents;
+    const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
+    const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
+    const invalidConfiguredAgents = Object.keys(config.agentConfigs).filter((identifier) => !validAgentIdentifiers.has(identifier));
+    if (invalidConfiguredAgents.length > 0) {
+        throw (0, constants_1.createRulerError)(`Invalid agent configured: ${invalidConfiguredAgents.join(', ')}`, `Valid agents are: ${[...validAgentIdentifiers].join(', ')}`);
+    }
     if (config.cliAgents && config.cliAgents.length > 0) {
         const filters = config.cliAgents.map((n) => n.toLowerCase());
         // Check if any of the specified agents don't exist
-        const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
-        const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
         const invalidAgents = filters.filter((filter) => !validAgentIdentifiers.has(filter) &&
             ![...validAgentNames].some((name) => name.includes(filter)));
         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());
         // Check if any of the default agents don't exist
-        const validAgentIdentifiers = new Set(allAgents.map((agent) => agent.getIdentifier()));
-        const validAgentNames = new Set(allAgents.map((agent) => agent.getName().toLowerCase()));
         const invalidAgents = defaults.filter((filter) => !validAgentIdentifiers.has(filter) &&
             ![...validAgentNames].some((name) => name.includes(filter)));
         if (invalidAgents.length > 0) {
@@ -42,7 +52,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,70 @@
+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;
+    projectRoot: string;
+}
+/**
+ * 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>;