@intellectronica/ruler 0.3.9 → 0.3.10

package/README.md

@@ -82,6 +82,7 @@ Ruler solves this by providing a **single source of truth** for all your AI agen
 | Trae AI          | `.trae/rules/project_rules.md`                   | -                                                |
 | Warp             | `WARP.md`                                        | -                                                |
 | Kiro             | `.kiro/steering/ruler_kiro_instructions.md`      | -                                                |
+| Firebender       | `firebender.json`                                | -                                                |
 
 ## Getting Started
 
@@ -214,7 +215,7 @@ The `apply` command looks for `.ruler/` in the current directory tree, reading t
 | Option                         | Description                                                                                                                                                                     |
 | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `--project-root <path>`        | Path to your project's root (default: current directory)                                                                                                                        |
-| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to target (agentsmd, aider, amazonqcli, amp, augmentcode, claude, cline, codex, copilot, crush, cursor, firebase, gemini-cli, goose, jules, junie, kilocode, kiro, opencode, openhands, qwen, roo, trae, warp, windsurf, zed) |
+| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to target (agentsmd, aider, amazonqcli, amp, augmentcode, claude, cline, codex, copilot, crush, cursor, firebase, firebender, gemini-cli, goose, jules, junie, kilocode, kiro, opencode, openhands, qwen, roo, trae, warp, windsurf, zed) |
 | `--config <path>`              | Path to a custom `ruler.toml` configuration file                                                                                                                                |
 | `--mcp` / `--with-mcp`         | Enable applying MCP server configurations (default: true)                                                                                                                       |
 | `--no-mcp`                     | Disable applying MCP server configurations                                                                                                                                      |
@@ -307,7 +308,7 @@ ruler revert [options]
 | Option                         | Description                                                                                                                                                                  |
 | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `--project-root <path>`        | Path to your project's root (default: current directory)                                                                                                                     |
-| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to revert (agentsmd, aider, amazonqcli, amp, augmentcode, claude, cline, codex, copilot, crush, cursor, firebase, gemini-cli, goose, jules, junie, kilocode, kiro, opencode, openhands, qwen, roo, trae, warp, windsurf, zed) |
+| `--agents <agent1,agent2,...>` | Comma-separated list of agent names to revert (agentsmd, aider, amazonqcli, amp, augmentcode, claude, cline, codex, copilot, crush, cursor, firebase, firebender, gemini-cli, goose, jules, junie, kilocode, kiro, opencode, openhands, qwen, roo, trae, warp, windsurf, zed) |
 | `--config <path>`              | Path to a custom `ruler.toml` configuration file                                                                                                                             |
 | `--keep-backups`               | Keep backup files (.bak) after restoration (default: false)                                                                                                                  |
 | `--dry-run`                    | Preview changes without actually reverting files                                                                                                                             |

package/dist/agents/FirebenderAgent.js

@@ -0,0 +1,205 @@
+"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.FirebenderAgent = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+/**
+ * Firebender agent adapter.
+ */
+class FirebenderAgent {
+    /**
+     * Type guard function to safely check if an object is a FirebenderRule.
+     */
+    isFirebenderRule(rule) {
+        return (typeof rule === 'object' &&
+            rule !== null &&
+            'filePathMatches' in rule &&
+            'rulesPaths' in rule &&
+            typeof rule.filePathMatches === 'string' &&
+            typeof rule.rulesPaths === 'string');
+    }
+    getIdentifier() {
+        return 'firebender';
+    }
+    getName() {
+        return 'Firebender';
+    }
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
+        const rulesPath = this.resolveOutputPath(projectRoot, agentConfig);
+        await (0, FileSystemUtils_1.ensureDirExists)(path.dirname(rulesPath));
+        const firebenderConfig = await this.loadExistingConfig(rulesPath);
+        const newRules = this.createRulesFromConcatenatedRules(concatenatedRules, projectRoot);
+        firebenderConfig.rules.push(...newRules);
+        this.removeDuplicateRules(firebenderConfig);
+        const mcpEnabled = agentConfig?.mcp?.enabled ?? true;
+        if (mcpEnabled && rulerMcpJson) {
+            await this.handleMcpConfiguration(firebenderConfig, rulerMcpJson, agentConfig);
+        }
+        await this.saveConfig(rulesPath, firebenderConfig, backup);
+    }
+    resolveOutputPath(projectRoot, agentConfig) {
+        const outputPaths = this.getDefaultOutputPath(projectRoot);
+        const output = agentConfig?.outputPath ??
+            agentConfig?.outputPathInstructions ??
+            outputPaths['instructions'];
+        return path.resolve(projectRoot, output);
+    }
+    async loadExistingConfig(rulesPath) {
+        try {
+            const existingContent = await fs.promises.readFile(rulesPath, 'utf8');
+            const config = JSON.parse(existingContent);
+            if (!config.rules) {
+                config.rules = [];
+            }
+            return config;
+        }
+        catch (error) {
+            if (error &&
+                typeof error === 'object' &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return { rules: [] };
+            }
+            console.warn(`Failed to read/parse existing firebender.json: ${error}`);
+            return { rules: [] };
+        }
+    }
+    createRulesFromConcatenatedRules(concatenatedRules, projectRoot) {
+        const filePaths = this.extractFilePathsFromRules(concatenatedRules, projectRoot);
+        if (filePaths.length > 0) {
+            return this.createRuleObjectsFromFilePaths(filePaths);
+        }
+        else {
+            return this.createRulesFromPlainText(concatenatedRules);
+        }
+    }
+    createRuleObjectsFromFilePaths(filePaths) {
+        return filePaths.map((filePath) => ({
+            filePathMatches: '**/*',
+            rulesPaths: filePath,
+        }));
+    }
+    createRulesFromPlainText(concatenatedRules) {
+        return concatenatedRules.split('\n').filter((rule) => rule.trim());
+    }
+    removeDuplicateRules(firebenderConfig) {
+        const seen = new Set();
+        firebenderConfig.rules = firebenderConfig.rules.filter((rule) => {
+            let key;
+            if (this.isFirebenderRule(rule)) {
+                const filePathMatchesPart = rule.filePathMatches;
+                const rulesPathsPart = rule.rulesPaths;
+                key = `${filePathMatchesPart}::${rulesPathsPart}`;
+            }
+            else {
+                key = String(rule);
+            }
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+    }
+    async saveConfig(rulesPath, config, backup) {
+        const updatedContent = JSON.stringify(config, null, 2);
+        if (backup) {
+            await (0, FileSystemUtils_1.backupFile)(rulesPath);
+        }
+        await (0, FileSystemUtils_1.writeGeneratedFile)(rulesPath, updatedContent);
+    }
+    /**
+     * Handle MCP server configuration for Firebender.
+     * Merges or overwrites MCP servers in the firebender.json configuration based on strategy.
+     */
+    async handleMcpConfiguration(firebenderConfig, rulerMcpJson, agentConfig) {
+        const strategy = agentConfig?.mcp?.strategy ?? 'merge';
+        const incomingServers = rulerMcpJson.mcpServers || {};
+        if (!firebenderConfig.mcpServers) {
+            firebenderConfig.mcpServers = {};
+        }
+        if (strategy === 'overwrite') {
+            firebenderConfig.mcpServers = { ...incomingServers };
+        }
+        else if (strategy === 'merge') {
+            const existingServers = firebenderConfig.mcpServers || {};
+            firebenderConfig.mcpServers = { ...existingServers, ...incomingServers };
+        }
+    }
+    getDefaultOutputPath(projectRoot) {
+        return {
+            instructions: path.join(projectRoot, 'firebender.json'),
+            mcp: path.join(projectRoot, 'firebender.json'),
+        };
+    }
+    getMcpServerKey() {
+        return 'mcpServers';
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return true;
+    }
+    /**
+     * Extracts file paths from concatenated rules by parsing HTML source comments.
+     * @param concatenatedRules The concatenated rules string with HTML comments
+     * @param projectRoot The project root directory
+     * @returns Array of file paths relative to project root
+     */
+    extractFilePathsFromRules(concatenatedRules, projectRoot) {
+        const sourceCommentRegex = /<!-- Source: (.+?) -->/g;
+        const filePaths = [];
+        let match;
+        while ((match = sourceCommentRegex.exec(concatenatedRules)) !== null) {
+            const relativePath = match[1];
+            const absolutePath = path.resolve(projectRoot, relativePath);
+            const normalizedProjectRoot = path.resolve(projectRoot);
+            // Ensure the absolutePath is within the project root (cross-platform compatible)
+            // This prevents path traversal attacks while handling Windows/Unix path differences
+            const isWithinProject = absolutePath.startsWith(normalizedProjectRoot) &&
+                (absolutePath.length === normalizedProjectRoot.length ||
+                    absolutePath[normalizedProjectRoot.length] === path.sep);
+            if (isWithinProject) {
+                const projectRelativePath = path.relative(projectRoot, absolutePath);
+                filePaths.push(projectRelativePath);
+            }
+        }
+        return filePaths;
+    }
+}
+exports.FirebenderAgent = FirebenderAgent;

package/dist/agents/index.js

@@ -30,6 +30,7 @@ const WarpAgent_1 = require("./WarpAgent");
 const RooCodeAgent_1 = require("./RooCodeAgent");
 const TraeAgent_1 = require("./TraeAgent");
 const AmazonQCliAgent_1 = require("./AmazonQCliAgent");
+const FirebenderAgent_1 = require("./FirebenderAgent");
 exports.allAgents = [
     new CopilotAgent_1.CopilotAgent(),
     new ClaudeAgent_1.ClaudeAgent(),
@@ -57,6 +58,7 @@ exports.allAgents = [
     new RooCodeAgent_1.RooCodeAgent(),
     new TraeAgent_1.TraeAgent(),
     new AmazonQCliAgent_1.AmazonQCliAgent(),
+    new FirebenderAgent_1.FirebenderAgent(),
 ];
 /**
  * Generates a comma-separated list of agent identifiers for CLI help text.

package/package.json

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