@intellectronica/ruler 0.3.40 → 0.3.42

package/dist/agents/IAgent.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Interface defining an AI agent configuration adapter.
+ */
+import { McpConfig } from '../types';
+/**
+ * Configuration overrides for a specific agent.
+ */
+export interface IAgentConfig {
+    /** Explicit enable/disable agent */
+    enabled?: boolean;
+    /** Override for primary output path */
+    outputPath?: string;
+    /** Override for Aider instruction file path */
+    outputPathInstructions?: string;
+    /** Override for Aider config file path */
+    outputPathConfig?: string;
+    /** MCP propagation config for this agent. */
+    mcp?: McpConfig;
+}
+export interface IAgent {
+    /**
+     * Returns the lowercase identifier of the agent (e.g., "copilot", "claude", "aider").
+     */
+    getIdentifier(): string;
+    /**
+     * Returns the display name of the agent.
+     */
+    getName(): string;
+    /**
+     * Applies the concatenated ruler rules to the agent's configuration.
+     * @param concatenatedRules The combined rules text
+     * @param projectRoot The root directory of the project
+     */
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, rulerMcpJson: Record<string, unknown> | null, agentConfig?: IAgentConfig, backup?: boolean): Promise<void>;
+    /**
+     * Returns the default output path(s) for this agent given the project root.
+     */
+    getDefaultOutputPath(projectRoot: string): string | Record<string, string>;
+    /**
+     * Returns the specific key to be used for the server object in MCP JSON.
+     * Defaults to 'mcpServers' if not implemented.
+     */
+    getMcpServerKey?(): string;
+    /**
+     * Returns whether this agent supports MCP STDIO servers.
+     * Defaults to false if not implemented.
+     */
+    supportsMcpStdio?(): boolean;
+    /**
+     * Returns whether this agent supports MCP remote servers.
+     * Defaults to false if not implemented.
+     */
+    supportsMcpRemote?(): boolean;
+    /**
+     * Returns whether this agent supports MCP server timeout configuration.
+     * Defaults to false if not implemented.
+     */
+    supportsMcpTimeout?(): boolean;
+    /**
+     * Returns whether this agent has native skills support (like Claude Code).
+     * When true, skills are copied directly to the agent's skills directory.
+     * Defaults to false if not implemented.
+     */
+    supportsNativeSkills?(): boolean;
+    /**
+     * Returns whether this agent has native subagent support (like Claude Code,
+     * Cursor, Codex CLI, GitHub Copilot). When true, subagent definitions from
+     * `.ruler/agents/` are propagated to the agent's native subagent location.
+     * Defaults to false if not implemented.
+     */
+    supportsNativeSubagents?(): boolean;
+}

package/dist/agents/JetBrainsAiAssistantAgent.d.ts

@@ -0,0 +1,10 @@
+import { AbstractAgent } from './AbstractAgent';
+/**
+ * JetBrains AI Assistant agent adapter.
+ * Writes rules to .aiassistant/rules/AGENTS.md.
+ */
+export declare class JetBrainsAiAssistantAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+}

package/dist/agents/JulesAgent.d.ts

@@ -0,0 +1,5 @@
+import { AgentsMdAgent } from './AgentsMdAgent';
+export declare class JulesAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+}

package/dist/agents/JunieAgent.d.ts

@@ -0,0 +1,12 @@
+import { AbstractAgent } from './AbstractAgent';
+/**
+ * JetBrains Junie agent adapter.
+ */
+export declare class JunieAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/KiloCodeAgent.d.ts

@@ -0,0 +1,14 @@
+import { AgentsMdAgent } from './AgentsMdAgent';
+/**
+ * Kilo Code agent adapter.
+ * Uses AGENTS.md for instructions and .kilocode/mcp.json for MCP configuration.
+ */
+export declare class KiloCodeAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+    getMcpServerKey(): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/KiroAgent.d.ts

@@ -0,0 +1,8 @@
+import { AbstractAgent } from './AbstractAgent';
+export declare class KiroAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+}

package/dist/agents/MistralVibeAgent.d.ts

@@ -0,0 +1,31 @@
+import { IAgent, IAgentConfig } from './IAgent';
+interface RulerMcpServer {
+    command?: string;
+    args?: string[];
+    url?: string;
+    headers?: Record<string, string>;
+    env?: Record<string, string>;
+    timeout?: number;
+}
+interface RulerMcp {
+    mcpServers?: Record<string, RulerMcpServer>;
+}
+/**
+ * Mistral Vibe CLI agent adapter.
+ * Propagates rules to AGENTS.md and MCP servers to .vibe/config.toml.
+ */
+export declare class MistralVibeAgent implements IAgent {
+    private agentsMdAgent;
+    getIdentifier(): string;
+    getName(): string;
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, rulerMcpJson: RulerMcp | null, agentConfig?: IAgentConfig, backup?: boolean): Promise<void>;
+    /**
+     * Determines the transport type based on server configuration.
+     */
+    private determineTransport;
+    getDefaultOutputPath(projectRoot: string): Record<string, string>;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsNativeSkills(): boolean;
+}
+export {};

package/dist/agents/OpenCodeAgent.d.ts

@@ -0,0 +1,11 @@
+import { IAgent, IAgentConfig } from './IAgent';
+export declare class OpenCodeAgent implements IAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): Record<string, string>;
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, rulerMcpJson: Record<string, unknown> | null, agentConfig?: IAgentConfig): Promise<void>;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsMcpTimeout(): boolean;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/OpenCodeAgent.js

@@ -51,9 +51,15 @@ class OpenCodeAgent {
     }
     async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig) {
         const outputPaths = this.getDefaultOutputPath(projectRoot);
-        const instructionsPath = path.resolve(projectRoot, agentConfig?.outputPathInstructions ?? outputPaths['instructions']);
+        const instructionsPath = path.resolve(projectRoot, agentConfig?.outputPath ??
+            agentConfig?.outputPathInstructions ??
+            outputPaths['instructions']);
         const mcpPath = path.resolve(projectRoot, agentConfig?.outputPathConfig ?? outputPaths['mcp']);
+        await fs.mkdir(path.dirname(instructionsPath), { recursive: true });
         await fs.writeFile(instructionsPath, concatenatedRules);
+        if (!rulerMcpJson) {
+            return;
+        }
         // Create OpenCode config with schema and MCP configuration
         let finalMcpConfig = {
             $schema: 'https://opencode.ai/config.json',
@@ -71,22 +77,21 @@ class OpenCodeAgent {
                     },
                 };
             }
-            else if (rulerMcpJson) {
+            else {
                 finalMcpConfig = {
                     $schema: 'https://opencode.ai/config.json',
-                    mcp: (rulerMcpJson?.mcpServers ?? {}),
+                    mcp: (rulerMcpJson.mcpServers ?? {}),
                 };
             }
         }
         catch {
-            if (rulerMcpJson) {
-                finalMcpConfig = {
-                    $schema: 'https://opencode.ai/config.json',
-                    mcp: (rulerMcpJson?.mcpServers ?? {}),
-                };
-            }
+            finalMcpConfig = {
+                $schema: 'https://opencode.ai/config.json',
+                mcp: (rulerMcpJson.mcpServers ?? {}),
+            };
         }
         // Always write the config file, even if MCP is empty
+        await fs.mkdir(path.dirname(mcpPath), { recursive: true });
         await fs.writeFile(mcpPath, JSON.stringify(finalMcpConfig, null, 2));
     }
     supportsMcpStdio() {

package/dist/agents/OpenHandsAgent.d.ts

@@ -0,0 +1,8 @@
+import { AbstractAgent } from './AbstractAgent';
+export declare class OpenHandsAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+}

package/dist/agents/PiAgent.d.ts

@@ -0,0 +1,9 @@
+import { AgentsMdAgent } from './AgentsMdAgent';
+/**
+ * Pi Coding Agent adapter.
+ */
+export declare class PiAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/QwenCodeAgent.d.ts

@@ -0,0 +1,10 @@
+import { IAgentConfig } from './IAgent';
+import { AgentsMdAgent } from './AgentsMdAgent';
+export declare class QwenCodeAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, _rulerMcpJson: Record<string, unknown> | null, agentConfig?: IAgentConfig, backup?: boolean): Promise<void>;
+    getMcpServerKey(): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+}

package/dist/agents/QwenCodeAgent.js

@@ -44,11 +44,11 @@ class QwenCodeAgent extends AgentsMdAgent_1.AgentsMdAgent {
     getName() {
         return 'Qwen Code';
     }
-    async applyRulerConfig(concatenatedRules, projectRoot, _rulerMcpJson, agentConfig) {
+    async applyRulerConfig(concatenatedRules, projectRoot, _rulerMcpJson, agentConfig, backup = true) {
         // First, perform idempotent write of AGENTS.md via base class
         await super.applyRulerConfig(concatenatedRules, projectRoot, null, {
             outputPath: agentConfig?.outputPath,
-        });
+        }, backup);
         // Ensure .qwen/settings.json has contextFileName set to AGENTS.md
         const settingsPath = path.join(projectRoot, '.qwen', 'settings.json');
         let existingSettings = {};

package/dist/agents/RooCodeAgent.d.ts

@@ -0,0 +1,16 @@
+import { IAgent, IAgentConfig } from './IAgent';
+/**
+ * Agent for RooCode that writes to AGENTS.md and generates .roo/mcp.json
+ * with project-level MCP server configuration.
+ */
+export declare class RooCodeAgent implements IAgent {
+    private agentsMdAgent;
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): Record<string, string>;
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, rulerMcpJson: Record<string, unknown> | null, agentConfig?: IAgentConfig, backup?: boolean): Promise<void>;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    getMcpServerKey(): string;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/TraeAgent.d.ts

@@ -0,0 +1,10 @@
+import { AbstractAgent } from './AbstractAgent';
+/**
+ * Trae AI agent adapter.
+ * Generates project_rules.md configuration file.
+ */
+export declare class TraeAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+}

package/dist/agents/WarpAgent.d.ts

@@ -0,0 +1,12 @@
+import { AbstractAgent } from './AbstractAgent';
+/**
+ * Warp Agent Mode adapter.
+ * Generates WARP.md configuration file in the project root.
+ */
+export declare class WarpAgent extends AbstractAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getDefaultOutputPath(projectRoot: string): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+}

package/dist/agents/WindsurfAgent.d.ts

@@ -0,0 +1,13 @@
+import { AgentsMdAgent } from './AgentsMdAgent';
+/**
+ * Windsurf agent adapter.
+ * Now uses AGENTS.md format like other agents.
+ */
+export declare class WindsurfAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+    getMcpServerKey(): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsNativeSkills(): boolean;
+}

package/dist/agents/ZedAgent.d.ts

@@ -0,0 +1,21 @@
+import { AgentsMdAgent } from './AgentsMdAgent';
+import { IAgentConfig } from './IAgent';
+/**
+ * Zed editor agent adapter.
+ * Inherits from AgentsMdAgent to write instructions to AGENTS.md and handles
+ * MCP server configuration in .zed/settings.json at the project root.
+ */
+export declare class ZedAgent extends AgentsMdAgent {
+    getIdentifier(): string;
+    getName(): string;
+    applyRulerConfig(concatenatedRules: string, projectRoot: string, rulerMcpJson: Record<string, unknown> | null, agentConfig?: IAgentConfig, backup?: boolean): Promise<void>;
+    getMcpServerKey(): string;
+    supportsMcpStdio(): boolean;
+    supportsMcpRemote(): boolean;
+    supportsNativeSkills(): boolean;
+    /**
+     * Transform MCP server configuration from ruler format to Zed format.
+     * Converts "type": "stdio" to "source": "custom" and preserves other fields.
+     */
+    private transformMcpServerForZed;
+}

package/dist/agents/ZedAgent.js

@@ -49,11 +49,11 @@ class ZedAgent extends AgentsMdAgent_1.AgentsMdAgent {
     getName() {
         return 'Zed';
     }
-    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig) {
+    async applyRulerConfig(concatenatedRules, projectRoot, rulerMcpJson, agentConfig, backup = true) {
         // First, perform idempotent AGENTS.md write via base class
         await super.applyRulerConfig(concatenatedRules, projectRoot, null, {
             outputPath: agentConfig?.outputPath,
-        });
+        }, backup);
         // Handle MCP server configuration if enabled and provided
         const mcpEnabled = agentConfig?.mcp?.enabled ?? true;
         if (mcpEnabled && rulerMcpJson) {
@@ -116,6 +116,9 @@ class ZedAgent extends AgentsMdAgent_1.AgentsMdAgent {
     supportsMcpRemote() {
         return true;
     }
+    supportsNativeSkills() {
+        return true;
+    }
     /**
      * Transform MCP server configuration from ruler format to Zed format.
      * Converts "type": "stdio" to "source": "custom" and preserves other fields.

package/dist/agents/agent-utils.d.ts

@@ -0,0 +1,5 @@
+import { IAgent, IAgentConfig } from './IAgent';
+/**
+ * Gets all output paths for an agent, taking into account any config overrides.
+ */
+export declare function getAgentOutputPaths(agent: IAgent, projectRoot: string, agentConfig?: IAgentConfig): string[];

package/dist/agents/agent-utils.js

@@ -17,17 +17,20 @@ function getAgentOutputPaths(agent, projectRoot, agentConfig) {
         const defaultPaths = defaults;
         // Handle instructions path
         if ('instructions' in defaultPaths) {
-            const instructionsPath = agentConfig?.outputPathInstructions ?? defaultPaths.instructions;
+            const instructionsPath = agentConfig?.outputPath ??
+                agentConfig?.outputPathInstructions ??
+                defaultPaths.instructions;
             paths.push(instructionsPath);
         }
-        // Handle config path
-        if ('config' in defaultPaths) {
-            const configPath = agentConfig?.outputPathConfig ?? defaultPaths.config;
+        // Handle config/MCP path
+        const configKey = 'config' in defaultPaths ? 'config' : 'mcp';
+        if (configKey in defaultPaths) {
+            const configPath = agentConfig?.outputPathConfig ?? defaultPaths[configKey];
             paths.push(configPath);
         }
         // Handle any other paths in the default paths record
         for (const [key, defaultPath] of Object.entries(defaultPaths)) {
-            if (key !== 'instructions' && key !== 'config') {
+            if (key !== 'instructions' && key !== configKey) {
                 // For unknown path types, use the default since we don't have specific config overrides
                 paths.push(defaultPath);
             }

package/dist/agents/index.d.ts

@@ -0,0 +1,9 @@
+import { IAgent } from './IAgent';
+import { AbstractAgent } from './AbstractAgent';
+export { AbstractAgent };
+export declare const allAgents: IAgent[];
+/**
+ * Generates a comma-separated list of agent identifiers for CLI help text.
+ * Returns identifiers in alphabetical order, with 'agentsmd' always first.
+ */
+export declare function getAgentIdentifiersForCliHelp(): string;

package/dist/cli/commands.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sets up and parses CLI commands.
+ */
+export declare function run(): void;

package/dist/cli/commands.js

@@ -71,8 +71,7 @@ function run() {
         })
             .option('backup', {
             type: 'boolean',
-            description: 'Enable/disable creation of .bak backup files (default: enabled)',
-            default: true,
+            description: 'Enable/disable creation of .bak backup files (default: from config or enabled)',
         })
             .option('skills', {
             type: 'boolean',
@@ -80,7 +79,7 @@ function run() {
         })
             .option('subagents', {
             type: 'boolean',
-            description: 'Enable/disable subagents support (experimental, default: enabled)',
+            description: 'Enable/disable subagents support (experimental, default: disabled)',
         });
     }, handlers_1.applyHandler)
         .command('init', 'Scaffold a .ruler directory with default files', (y) => {

package/dist/cli/handlers.d.ts

@@ -0,0 +1,41 @@
+export interface ApplyArgs {
+    'project-root': string;
+    agents?: string;
+    config?: string;
+    mcp: boolean;
+    'mcp-overwrite': boolean;
+    gitignore?: boolean;
+    'gitignore-local'?: boolean;
+    verbose: boolean;
+    'dry-run': boolean;
+    'local-only': boolean;
+    nested?: boolean;
+    backup?: boolean;
+    skills?: boolean;
+    subagents?: boolean;
+}
+export interface InitArgs {
+    'project-root': string;
+    global: boolean;
+}
+export interface RevertArgs {
+    'project-root': string;
+    agents?: string;
+    config?: string;
+    'keep-backups': boolean;
+    verbose: boolean;
+    'dry-run': boolean;
+    'local-only': boolean;
+}
+/**
+ * Handler for the 'apply' command.
+ */
+export declare function applyHandler(argv: ApplyArgs): Promise<void>;
+/**
+ * Handler for the 'init' command.
+ */
+export declare function initHandler(argv: InitArgs): Promise<void>;
+/**
+ * Handler for the 'revert' command.
+ */
+export declare function revertHandler(argv: RevertArgs): Promise<void>;