@intellectronica/ruler 0.3.1 → 0.3.2

package/dist/agents/AbstractAgent.js

@@ -50,11 +50,13 @@ class AbstractAgent {
      * 4. Writing the new content
      */
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, concatenatedRules);
     }
     /**

package/dist/agents/AgentsMdAgent.js

@@ -54,7 +54,7 @@ class AgentsMdAgent extends AbstractAgent_1.AbstractAgent {
         return path.join(projectRoot, 'AGENTS.md');
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
@@ -72,8 +72,10 @@ class AgentsMdAgent extends AbstractAgent_1.AbstractAgent {
             // No change; skip backup/write for idempotency
             return;
         }
-        // Backup (only if file existed) then write new content
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        // Backup (only if file existed and backup is enabled) then write new content
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, contentWithMarker);
     }
     getMcpServerKey() {

package/dist/agents/AiderAgent.js

@@ -52,21 +52,23 @@ class AiderAgent {
     getName() {
         return 'Aider';
     }
-    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig) {
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
         // First perform idempotent AGENTS.md write via composed AgentsMdAgent
         await this.agentsMdAgent.applyRulerConfig(concatenatedRules, projectRoot, null, {
             // Preserve explicit outputPath precedence semantics if provided.
             outputPath: agentConfig?.outputPath ||
                 agentConfig?.outputPathInstructions ||
                 undefined,
-        });
+        }, backup);
         // Now handle .aider.conf.yml configuration
         const cfgPath = agentConfig?.outputPathConfig ??
             this.getDefaultOutputPath(projectRoot).config;
         let doc = {};
         try {
             await fs.access(cfgPath);
-            await (0, FileSystemUtils_1.backupFile)(cfgPath);
+            if (backup) {
+                await (0, FileSystemUtils_1.backupFile)(cfgPath);
+            }
             const raw = await fs.readFile(cfgPath, 'utf8');
             doc = (yaml.load(raw) || {});
         }

package/dist/agents/AugmentCodeAgent.js

@@ -48,9 +48,11 @@ class AugmentCodeAgent {
         return 'AugmentCode';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
-        await (0, FileSystemUtils_1.backupFile)(output);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(output);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(output, concatenatedRules);
         // AugmentCode does not support MCP servers
         // MCP configuration is ignored for this agent

package/dist/agents/CursorAgent.js

@@ -48,7 +48,7 @@ class CursorAgent extends AbstractAgent_1.AbstractAgent {
         return 'Cursor';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         // Cursor expects a YAML front-matter block with an `alwaysApply` flag.
@@ -56,7 +56,9 @@ class CursorAgent extends AbstractAgent_1.AbstractAgent {
         const frontMatter = ['---', 'alwaysApply: true', '---', ''].join('\n');
         const content = `${frontMatter}${concatenatedRules.trimStart()}`;
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
     }
     getDefaultOutputPath(projectRoot) {

package/dist/agents/WindsurfAgent.js

@@ -48,14 +48,16 @@ class WindsurfAgent extends AbstractAgent_1.AbstractAgent {
         return 'Windsurf';
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, // eslint-disable-line @typescript-eslint/no-unused-vars
-    agentConfig) {
+    agentConfig, backup = true) {
         const output = agentConfig?.outputPath ?? this.getDefaultOutputPath(projectRoot);
         const absolutePath = path.resolve(projectRoot, output);
         // Windsurf expects a YAML front-matter block with a `trigger` flag.
         const frontMatter = ['---', 'trigger: always_on', '---', ''].join('\n');
         const content = `${frontMatter}${concatenatedRules.trimStart()}`;
         await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(absolutePath));
-        await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(absolutePath);
+        }
         await (0, FileSystemUtils_1.writeGeneratedFile)(absolutePath, content);
     }
     getDefaultOutputPath(projectRoot) {

package/dist/cli/commands.js

@@ -64,6 +64,11 @@ function run() {
             type: 'boolean',
             description: 'Enable nested rule loading from nested .ruler directories (default: disabled)',
             default: false,
+        })
+            .option('backup', {
+            type: 'boolean',
+            description: 'Enable/disable creation of .bak backup files (default: enabled)',
+            default: true,
         });
     }, handlers_1.applyHandler)
         .command('init', 'Scaffold a .ruler directory with default files', (y) => {

package/dist/cli/handlers.js

@@ -59,6 +59,7 @@ async function applyHandler(argv) {
     const dryRun = argv['dry-run'];
     const localOnly = argv['local-only'];
     const nested = argv.nested;
+    const backup = argv.backup;
     // Determine gitignore preference: CLI > TOML > Default (enabled)
     // yargs handles --no-gitignore by setting gitignore to false
     let gitignorePreference;
@@ -69,7 +70,7 @@ async function applyHandler(argv) {
         gitignorePreference = undefined; // Let TOML/default decide
     }
     try {
-        await (0, lib_1.applyAllAgentConfigs)(projectRoot, agents, configPath, mcpEnabled, mcpStrategy, gitignorePreference, verbose, dryRun, localOnly, nested);
+        await (0, lib_1.applyAllAgentConfigs)(projectRoot, agents, configPath, mcpEnabled, mcpStrategy, gitignorePreference, verbose, dryRun, localOnly, nested, backup);
         console.log('Ruler apply completed successfully.');
     }
     catch (err) {

package/dist/core/apply-engine.js

@@ -218,12 +218,12 @@ function selectAgentsToRun(allAgents, config) {
  * @param cliMcpStrategy MCP strategy from CLI
  * @returns Promise resolving to array of generated file paths
  */
-async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy) {
+async function processHierarchicalConfigurations(agents, configurations, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup = true) {
     const allGeneratedPaths = [];
     for (const config of configurations) {
         console.log(`[ruler] Processing .ruler directory: ${config.rulerDir}`);
         const rulerRoot = path.dirname(config.rulerDir);
-        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        const paths = await applyConfigurationsToAgents(agents, config.concatenatedRules, config.rulerMcpJson, config.config, rulerRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
         allGeneratedPaths.push(...paths);
     }
     return allGeneratedPaths;
@@ -240,8 +240,8 @@ 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) {
-    return await applyConfigurationsToAgents(agents, configuration.concatenatedRules, configuration.rulerMcpJson, configuration.config, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+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);
 }
 /**
  * Applies configurations to the selected agents (internal function).
@@ -254,7 +254,7 @@ 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) {
+async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJson, config, projectRoot, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true) {
     const generatedPaths = [];
     let agentsMdWritten = false;
     for (const agent of agents) {
@@ -266,9 +266,11 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
         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);
-        // Also add the backup file paths to the gitignore list
-        const backupPaths = outputPaths.map((p) => `${p}.bak`);
-        generatedPaths.push(...backupPaths);
+        // Only add the backup file paths to the gitignore list if backups are enabled
+        if (backup) {
+            const backupPaths = outputPaths.map((p) => `${p}.bak`);
+            generatedPaths.push(...backupPaths);
+        }
         if (dryRun) {
             (0, constants_1.logVerbose)(`DRY RUN: Would write rules to: ${outputPaths.join(', ')}`, verbose);
         }
@@ -299,15 +301,15 @@ async function applyConfigurationsToAgents(agents, concatenatedRules, rulerMcpJs
                 };
             }
             if (!skipApplyForThisAgent) {
-                await agent.applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, finalAgentConfig);
+                await agent.applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, finalAgentConfig, backup);
             }
         }
         // Handle MCP configuration
-        await handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy);
+        await handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
     return generatedPaths;
 }
-async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy) {
+async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson, projectRoot, generatedPaths, verbose, dryRun, cliMcpEnabled = true, cliMcpStrategy, backup = true) {
     if (!(0, capabilities_1.agentSupportsMcp)(agent)) {
         (0, constants_1.logVerbose)(`Agent ${agent.getName()} does not support MCP - skipping MCP configuration`, verbose);
         return;
@@ -322,47 +324,49 @@ async function handleMcpConfiguration(agent, agentConfig, config, rulerMcpJson,
         (0, constants_1.logVerbose)(`No compatible MCP servers found for ${agent.getName()} - skipping MCP configuration`, verbose);
         return;
     }
-    await updateGitignoreForMcpFile(dest, projectRoot, generatedPaths);
-    await applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose);
+    await updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup);
+    await applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup);
 }
-async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths) {
+async function updateGitignoreForMcpFile(dest, projectRoot, generatedPaths, backup = true) {
     if (dest.startsWith(projectRoot)) {
         const relativeDest = path.relative(projectRoot, dest);
         generatedPaths.push(relativeDest);
-        generatedPaths.push(`${relativeDest}.bak`);
+        if (backup) {
+            generatedPaths.push(`${relativeDest}.bak`);
+        }
     }
 }
-async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose) {
+async function applyMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, projectRoot, cliMcpStrategy, dryRun, verbose, backup = true) {
     // Prevent writing MCP configs outside the project root (e.g., legacy home-directory targets)
     if (!dest.startsWith(projectRoot)) {
         (0, constants_1.logVerbose)(`Skipping MCP config for ${agent.getName()} because target path is outside project: ${dest}`, verbose);
         return;
     }
     if (agent.getIdentifier() === 'openhands') {
-        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose);
+        return await applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
     }
     if (agent.getIdentifier() === 'opencode') {
-        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose);
+        return await applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose, backup);
     }
-    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose);
+    return await applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup);
 }
-async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, dryRun, verbose) {
+async function applyOpenHandsMcpConfiguration(filteredMcpJson, dest, 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);
+        await (0, propagateOpenHandsMcp_1.propagateMcpToOpenHands)(filteredMcpJson, dest, backup);
     }
 }
-async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, dryRun, verbose) {
+async function applyOpenCodeMcpConfiguration(filteredMcpJson, dest, 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);
+        await (0, propagateOpenCodeMcp_1.propagateMcpToOpenCode)(filteredMcpJson, dest, backup);
     }
 }
-async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose) {
+async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agentConfig, config, cliMcpStrategy, dryRun, verbose, backup = true) {
     const strategy = cliMcpStrategy ??
         agentConfig?.mcp?.strategy ??
         config.mcp?.strategy ??
@@ -373,6 +377,10 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
         (0, constants_1.logVerbose)(`DRY RUN: Would apply MCP config to: ${dest}`, verbose);
     }
     else {
+        if (backup) {
+            const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+            await backupFile(dest);
+        }
         const existing = await (0, mcp_1.readNativeMcp)(dest);
         const merged = (0, merge_1.mergeMcp)(existing, filteredMcpJson, strategy, serverKey);
         await (0, mcp_1.writeNativeMcp)(dest, merged);
@@ -386,7 +394,7 @@ async function applyStandardMcpConfiguration(agent, filteredMcpJson, dest, agent
  * @param cliGitignoreEnabled CLI gitignore setting
  * @param dryRun Whether to perform a dry run
  */
-async function updateGitignore(projectRoot, generatedPaths, config, cliGitignoreEnabled, dryRun) {
+async function updateGitignore(projectRoot, generatedPaths, config, cliGitignoreEnabled, dryRun, backup = true) {
     // Configuration precedence: CLI > TOML > Default (enabled)
     let gitignoreEnabled;
     if (cliGitignoreEnabled !== undefined) {
@@ -400,8 +408,10 @@ async function updateGitignore(projectRoot, generatedPaths, config, cliGitignore
     }
     if (gitignoreEnabled && generatedPaths.length > 0) {
         const uniquePaths = [...new Set(generatedPaths)];
-        // Add wildcard pattern for backup files
-        uniquePaths.push('*.bak');
+        // Add wildcard pattern for backup files only if backup is enabled
+        if (backup) {
+            uniquePaths.push('*.bak');
+        }
         if (uniquePaths.length > 0) {
             const prefix = (0, constants_1.actionPrefix)(dryRun);
             if (dryRun) {

package/dist/lib.js

@@ -17,7 +17,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) {
+async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cliMcpEnabled = true, cliMcpStrategy, cliGitignoreEnabled, verbose = false, dryRun = false, localOnly = false, nested = false, backup = true) {
     // Load configuration and rules
     (0, constants_1.logVerbose)(`Loading configuration from project root: ${projectRoot}`, verbose);
     if (configPath) {
@@ -40,7 +40,7 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         normalizeAgentConfigs(rootConfig, agents);
         selectedAgents = (0, apply_engine_1.selectAgentsToRun)(agents, rootConfig);
         (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);
+        generatedPaths = await (0, apply_engine_1.processHierarchicalConfigurations)(selectedAgents, hierarchicalConfigs, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
     else {
         const singleConfig = await (0, apply_engine_1.loadSingleConfiguration)(projectRoot, configPath, localOnly);
@@ -51,9 +51,9 @@ async function applyAllAgentConfigs(projectRoot, includedAgents, configPath, cli
         normalizeAgentConfigs(singleConfig.config, agents);
         selectedAgents = (0, apply_engine_1.selectAgentsToRun)(agents, singleConfig.config);
         (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);
+        generatedPaths = await (0, apply_engine_1.processSingleConfiguration)(selectedAgents, singleConfig, projectRoot, verbose, dryRun, cliMcpEnabled, cliMcpStrategy, backup);
     }
-    await (0, apply_engine_1.updateGitignore)(projectRoot, generatedPaths, loadedConfig, cliGitignoreEnabled, dryRun);
+    await (0, apply_engine_1.updateGitignore)(projectRoot, generatedPaths, loadedConfig, cliGitignoreEnabled, dryRun, backup);
 }
 /**
  * Normalizes per-agent config keys to agent identifiers for consistent lookup.

package/dist/mcp/propagateOpenCodeMcp.js

@@ -85,7 +85,7 @@ function transformToOpenCodeFormat(rulerMcp) {
         mcp: openCodeServers,
     };
 }
-async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath) {
+async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath, backup = true) {
     const rulerMcp = rulerMcpData || {};
     // Read existing OpenCode config if it exists
     let existingConfig = {};
@@ -108,5 +108,9 @@ async function propagateMcpToOpenCode(rulerMcpData, openCodeConfigPath) {
         },
     };
     await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openCodeConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openCodeConfigPath);
+    }
     await fs.writeFile(openCodeConfigPath, JSON.stringify(finalConfig, null, 2) + '\n');
 }

package/dist/mcp/propagateOpenHandsMcp.js

@@ -90,7 +90,7 @@ function normalizeRemoteServerArray(entries) {
     // All entries are strings, keep as is
     return entries;
 }
-async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath) {
+async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath, backup = true) {
     const rulerMcp = rulerMcpData || {};
     // Always use the legacy Ruler MCP config format as input (top-level "mcpServers" key)
     const rulerServers = rulerMcp.mcpServers || {};
@@ -162,5 +162,9 @@ async function propagateMcpToOpenHands(rulerMcpData, openHandsConfigPath) {
     config.mcp.sse_servers = normalizeRemoteServerArray(Array.from(existingSseServers.values()));
     config.mcp.shttp_servers = normalizeRemoteServerArray(Array.from(existingShttpServers.values()));
     await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(openHandsConfigPath));
+    if (backup) {
+        const { backupFile } = await Promise.resolve().then(() => __importStar(require('../core/FileSystemUtils')));
+        await backupFile(openHandsConfigPath);
+    }
     await fs.writeFile(openHandsConfigPath, (0, toml_1.stringify)(config));
 }

package/package.json

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