skiller 0.4.3

package/dist/agents/CodexCliAgent.js

@@ -0,0 +1,143 @@
+"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.CodexCliAgent = void 0;
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const toml_1 = require("@iarna/toml");
+const AgentsMdAgent_1 = require("./AgentsMdAgent");
+const FileSystemUtils_1 = require("../core/FileSystemUtils");
+const constants_1 = require("../constants");
+/**
+ * OpenAI Codex CLI agent adapter.
+ */
+class CodexCliAgent {
+    constructor() {
+        this.agentsMdAgent = new AgentsMdAgent_1.AgentsMdAgent();
+    }
+    getIdentifier() {
+        return 'codex';
+    }
+    getName() {
+        return 'OpenAI Codex CLI';
+    }
+    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);
+        // Use proper path resolution from getDefaultOutputPath and agentConfig
+        const defaults = this.getDefaultOutputPath(projectRoot);
+        const mcpEnabled = agentConfig?.mcp?.enabled ?? true;
+        if (mcpEnabled && rulerMcpJson) {
+            // Apply MCP server filtering and transformation
+            const { filterMcpConfigForAgent } = await Promise.resolve().then(() => __importStar(require('../mcp/capabilities')));
+            const filteredMcpConfig = filterMcpConfigForAgent(rulerMcpJson, this);
+            if (!filteredMcpConfig) {
+                return; // No compatible servers found
+            }
+            const filteredRulerMcpJson = filteredMcpConfig;
+            // Determine the config file path using proper precedence
+            const configPath = agentConfig?.outputPathConfig ?? defaults.config;
+            // Ensure the parent directory exists
+            await fs_1.promises.mkdir(path.dirname(configPath), { recursive: true });
+            // Get the merge strategy
+            const strategy = agentConfig?.mcp?.strategy ?? 'merge';
+            // Extract MCP servers from filtered ruler config
+            const rulerServers = filteredRulerMcpJson.mcpServers || {};
+            // Read existing TOML config if it exists
+            let existingConfig = {};
+            try {
+                const existingContent = await fs_1.promises.readFile(configPath, 'utf8');
+                existingConfig = (0, toml_1.parse)(existingContent);
+            }
+            catch {
+                // File doesn't exist or can't be parsed, use empty config
+            }
+            // Create the updated config
+            const updatedConfig = { ...existingConfig };
+            // Initialize mcp_servers if it doesn't exist
+            if (!updatedConfig.mcp_servers) {
+                updatedConfig.mcp_servers = {};
+            }
+            if (strategy === 'overwrite') {
+                // For overwrite strategy, replace the entire mcp_servers section
+                updatedConfig.mcp_servers = {};
+            }
+            // Add the ruler servers
+            for (const [serverName, serverConfig] of Object.entries(rulerServers)) {
+                // Create a properly formatted MCP server entry
+                const mcpServer = {
+                    command: serverConfig.command,
+                };
+                if (serverConfig.args) {
+                    mcpServer.args = serverConfig.args;
+                }
+                // Format env as an inline table
+                if (serverConfig.env) {
+                    mcpServer.env = serverConfig.env;
+                }
+                // Handle additional properties from remote server transformation
+                if (serverConfig.headers) {
+                    mcpServer.headers = serverConfig.headers;
+                }
+                if (updatedConfig.mcp_servers) {
+                    updatedConfig.mcp_servers[serverName] = mcpServer;
+                }
+            }
+            // Convert to TOML using structured objects
+            const finalConfig = { ...updatedConfig };
+            // @iarna/toml should handle the formatting properly
+            const tomlContent = (0, toml_1.stringify)(finalConfig);
+            await (0, FileSystemUtils_1.writeGeneratedFile)(configPath, tomlContent);
+        }
+    }
+    getDefaultOutputPath(projectRoot) {
+        return {
+            instructions: path.join(projectRoot, constants_1.DEFAULT_RULES_FILENAME),
+            config: path.join(projectRoot, '.codex', 'config.toml'),
+        };
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return false; // Codex CLI only supports STDIO based on PR description
+    }
+}
+exports.CodexCliAgent = CodexCliAgent;

package/dist/agents/CopilotAgent.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotAgent = void 0;
+const AgentsMdAgent_1 = require("./AgentsMdAgent");
+/**
+ * GitHub Copilot agent adapter.
+ * Writes to AGENTS.md for both web-based GitHub Copilot and VS Code extension.
+ */
+class CopilotAgent {
+    constructor() {
+        this.agentsMdAgent = new AgentsMdAgent_1.AgentsMdAgent();
+    }
+    getIdentifier() {
+        return 'copilot';
+    }
+    getName() {
+        return 'GitHub Copilot';
+    }
+    /**
+     * Returns the default output path for AGENTS.md.
+     */
+    getDefaultOutputPath(projectRoot) {
+        return this.agentsMdAgent.getDefaultOutputPath(projectRoot);
+    }
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
+        // Write to AGENTS.md using the existing AgentsMdAgent infrastructure
+        await this.agentsMdAgent.applyRulerConfig(concatenatedRules, projectRoot, null, // No MCP config needed for the instructions file
+        {
+            // Preserve explicit outputPath precedence semantics if provided
+            outputPath: agentConfig?.outputPath || agentConfig?.outputPathInstructions,
+        }, backup);
+    }
+    getMcpServerKey() {
+        return 'servers';
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return true;
+    }
+}
+exports.CopilotAgent = CopilotAgent;

package/dist/agents/CrushAgent.js

@@ -0,0 +1,128 @@
+"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.CrushAgent = void 0;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+class CrushAgent {
+    getIdentifier() {
+        return 'crush';
+    }
+    getName() {
+        return 'Crush';
+    }
+    getDefaultOutputPath(projectRoot) {
+        return {
+            instructions: path.join(projectRoot, 'CRUSH.md'),
+            mcp: path.join(projectRoot, '.crush.json'),
+        };
+    }
+    /**
+     * Transform MCP server types for Crush compatibility.
+     * Crush expects "http" for HTTP servers and "sse" for SSE servers, not "remote".
+     */
+    transformMcpServersForCrush(mcpServers) {
+        const transformedServers = {};
+        for (const [name, serverDef] of Object.entries(mcpServers)) {
+            if (serverDef && typeof serverDef === 'object') {
+                const server = serverDef;
+                const transformedServer = { ...server };
+                // Transform type: "remote" to appropriate Crush types
+                if (server.type === 'remote' &&
+                    server.url &&
+                    typeof server.url === 'string') {
+                    const url = server.url;
+                    // Check if URL suggests SSE (contains /sse path segment)
+                    if (/\/sse(\/|$)/i.test(url)) {
+                        transformedServer.type = 'sse';
+                    }
+                    else {
+                        transformedServer.type = 'http';
+                    }
+                }
+                transformedServers[name] = transformedServer;
+            }
+            else {
+                transformedServers[name] = serverDef;
+            }
+        }
+        return transformedServers;
+    }
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig) {
+        const outputPaths = this.getDefaultOutputPath(projectRoot);
+        const instructionsPath = agentConfig?.outputPathInstructions ?? outputPaths['instructions'];
+        const mcpPath = agentConfig?.outputPathConfig ?? outputPaths['mcp'];
+        await fs.writeFile(instructionsPath, concatenatedRules);
+        // Always transform from mcpServers ({ mcpServers: ... }) to { mcp: ... } for Crush
+        let finalMcpConfig = { mcp: {} };
+        try {
+            const existingMcpConfig = JSON.parse(await fs.readFile(mcpPath, 'utf-8'));
+            if (existingMcpConfig && typeof existingMcpConfig === 'object') {
+                const transformedServers = this.transformMcpServersForCrush((rulerMcpJson?.mcpServers ?? {}));
+                finalMcpConfig = {
+                    ...existingMcpConfig,
+                    mcp: {
+                        ...(existingMcpConfig.mcp || {}),
+                        ...transformedServers,
+                    },
+                };
+            }
+            else if (rulerMcpJson) {
+                const transformedServers = this.transformMcpServersForCrush((rulerMcpJson?.mcpServers ?? {}));
+                finalMcpConfig = {
+                    mcp: transformedServers,
+                };
+            }
+        }
+        catch {
+            if (rulerMcpJson) {
+                const transformedServers = this.transformMcpServersForCrush((rulerMcpJson?.mcpServers ?? {}));
+                finalMcpConfig = {
+                    mcp: transformedServers,
+                };
+            }
+        }
+        if (Object.keys(finalMcpConfig.mcp).length > 0) {
+            await fs.writeFile(mcpPath, JSON.stringify(finalMcpConfig, null, 2));
+        }
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return true;
+    }
+}
+exports.CrushAgent = CrushAgent;

package/dist/agents/CursorAgent.js

@@ -0,0 +1,93 @@
+"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.CursorAgent = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const AgentsMdAgent_1 = require("./AgentsMdAgent");
+const SkillsUtils_1 = require("../core/SkillsUtils");
+/**
+ * Cursor agent adapter.
+ * Leverages the standardized AGENTS.md approach supported natively by Cursor.
+ * See: https://docs.cursor.com/en/cli/using
+ */
+class CursorAgent extends AgentsMdAgent_1.AgentsMdAgent {
+    getIdentifier() {
+        return 'cursor';
+    }
+    getName() {
+        return 'Cursor';
+    }
+    async applyRulerConfig(concatenatedRules, projectRoot, _rulerMcpJson, agentConfig, backup = true, _ruleFiles, rulerDir, mergeStrategy) {
+        // Write AGENTS.md via base class
+        // Cursor natively reads AGENTS.md from the project root
+        await super.applyRulerConfig(concatenatedRules, projectRoot, null, {
+            outputPath: agentConfig?.outputPath,
+        }, backup);
+        // Copy .claude/rules to .cursor/rules when using cursor merge strategy
+        if (mergeStrategy === 'cursor' && rulerDir) {
+            const rulerDirName = path.basename(rulerDir);
+            if (rulerDirName === '.claude') {
+                const sourceRulesDir = path.join(rulerDir, 'rules');
+                const targetRulesDir = path.join(projectRoot, '.cursor', 'rules');
+                // Check if source rules directory exists
+                try {
+                    await fs.access(sourceRulesDir);
+                    // Copy the entire rules directory
+                    await fs.mkdir(path.dirname(targetRulesDir), { recursive: true });
+                    await fs.rm(targetRulesDir, { recursive: true, force: true });
+                    await (0, SkillsUtils_1.copySkillsDirectory)(sourceRulesDir, targetRulesDir);
+                }
+                catch {
+                    // Source rules directory doesn't exist, skip copying
+                }
+            }
+        }
+    }
+    getMcpServerKey() {
+        return 'mcpServers';
+    }
+    supportsMcpStdio() {
+        return true;
+    }
+    supportsMcpRemote() {
+        return true;
+    }
+    supportsNativeSkills() {
+        // Cursor has native support for rules via .cursor/rules/
+        return true;
+    }
+}
+exports.CursorAgent = CursorAgent;

package/dist/agents/FirebaseAgent.js

@@ -0,0 +1,61 @@
+"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.FirebaseAgent = void 0;
+const path = __importStar(require("path"));
+const AbstractAgent_1 = require("./AbstractAgent");
+/**
+ * Firebase Studio agent adapter.
+ */
+class FirebaseAgent extends AbstractAgent_1.AbstractAgent {
+    getIdentifier() {
+        return 'firebase';
+    }
+    getName() {
+        return 'Firebase Studio';
+    }
+    getDefaultOutputPath(projectRoot) {
+        return path.join(projectRoot, '.idx', 'airules.md');
+    }
+    // Firebase Studio (IDX) supports stdio MCP servers via .idx/mcp.json
+    supportsMcpStdio() {
+        return true;
+    }
+    // Remote MCP over HTTP/SSE is not documented for Firebase Studio yet
+    supportsMcpRemote() {
+        return false;
+    }
+}
+exports.FirebaseAgent = FirebaseAgent;

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;