ralph-cli-sandboxed 0.4.1 → 0.4.2

package/dist/providers/discord.js

@@ -6,6 +6,11 @@
  *   npm install discord.js
  */
 import { parseCommand, } from "../utils/chat-client.js";
+import { ResponderMatcher } from "../utils/responder.js";
+import { loadConfig } from "../utils/config.js";
+import { executeLLMResponder } from "../responders/llm-responder.js";
+import { executeClaudeCodeResponder } from "../responders/claude-code-responder.js";
+import { executeCLIResponder } from "../responders/cli-responder.js";
 // Discord.js classes loaded dynamically
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 let ClientConstructor = null;
@@ -50,9 +55,125 @@ export class DiscordChatClient {
     client = null;
     onCommand = null;
     onMessage = null;
+    responderMatcher = null;
+    respondersConfig = null;
+    botUserId = null;
     constructor(settings, debug = false) {
         this.settings = settings;
         this.debug = debug;
+        // Initialize responders from config if available
+        this.initializeResponders();
+    }
+    /**
+     * Initialize responder matching from config.
+     */
+    initializeResponders() {
+        try {
+            const config = loadConfig();
+            if (config.chat?.responders) {
+                this.respondersConfig = config.chat.responders;
+                this.responderMatcher = new ResponderMatcher(config.chat.responders);
+                if (this.debug) {
+                    console.log(`[discord] Initialized ${Object.keys(config.chat.responders).length} responders`);
+                }
+            }
+        }
+        catch {
+            // Config not available or responders not configured
+            if (this.debug) {
+                console.log("[discord] No responders configured");
+            }
+        }
+    }
+    /**
+     * Execute a responder and return the result.
+     */
+    async executeResponder(match, message) {
+        const { responder } = match;
+        switch (responder.type) {
+            case "llm":
+                return executeLLMResponder(message, responder);
+            case "claude-code":
+                return executeClaudeCodeResponder(message, responder);
+            case "cli":
+                return executeCLIResponder(message, responder);
+            default:
+                return {
+                    success: false,
+                    response: "",
+                    error: `Unknown responder type: ${responder.type}`,
+                };
+        }
+    }
+    /**
+     * Handle a message that might match a responder.
+     * Returns true if a responder was matched and executed.
+     */
+    async handleResponderMessage(originalMessage, cleanedText) {
+        if (!this.responderMatcher) {
+            return false;
+        }
+        const match = this.responderMatcher.matchResponder(cleanedText);
+        if (!match) {
+            return false;
+        }
+        if (this.debug) {
+            console.log(`[discord] Matched responder: ${match.name} (type: ${match.responder.type})`);
+        }
+        // Execute the responder
+        const result = await this.executeResponder(match, match.args || cleanedText);
+        // Send the response (reply to the original message for context)
+        try {
+            if (result.success) {
+                // Truncate to Discord's 2000 char limit
+                const responseText = result.response.substring(0, 2000);
+                await originalMessage.reply(responseText);
+            }
+            else {
+                const errorMsg = result.error
+                    ? `Error: ${result.error}`
+                    : "An error occurred while processing your message.";
+                await originalMessage.reply(errorMsg);
+            }
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[discord] Failed to send responder reply: ${err}`);
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if the bot is mentioned in a message.
+     */
+    isBotMentioned(message) {
+        if (!this.botUserId) {
+            return false;
+        }
+        // Check if the message mentions the bot user
+        if (message.mentions && typeof message.mentions.has === "function") {
+            return message.mentions.has(this.botUserId);
+        }
+        // Fallback: check text for <@BOT_ID> pattern
+        return message.content?.includes(`<@${this.botUserId}>`) || false;
+    }
+    /**
+     * Remove bot mention from message text.
+     */
+    removeBotMention(text) {
+        if (!this.botUserId) {
+            return text;
+        }
+        // Remove <@BOT_ID> and any surrounding whitespace
+        // Also handles <@!BOT_ID> format (with nickname)
+        return text.replace(new RegExp(`<@!?${this.botUserId}>\\s*`, "g"), "").trim();
+    }
+    /**
+     * Check if this is a DM (direct message) channel.
+     */
+    isDMChannel(message) {
+        // DM channels have type 1 (DM) or could check if guild is null
+        return message.channel?.type === 1 || !message.guild;
     }
     /**
      * Check if a guild ID is allowed.
@@ -96,19 +217,50 @@ export class DiscordChatClient {
         if (!this.client || !REST || !Routes || !SlashCommandBuilder)
             return;
         const commands = [
-            { name: "run", description: "Start ralph automation", hasArgs: true, argName: "category", argDesc: "Optional category filter" },
+            {
+                name: "run",
+                description: "Start ralph automation",
+                hasArgs: true,
+                argName: "category",
+                argDesc: "Optional category filter",
+            },
             { name: "status", description: "Show PRD progress", hasArgs: false },
-            { name: "add", description: "Add new task to PRD", hasArgs: true, argName: "description", argDesc: "Task description", required: true },
-            { name: "exec", description: "Execute shell command", hasArgs: true, argName: "command", argDesc: "Shell command to run", required: true },
+            {
+                name: "add",
+                description: "Add new task to PRD",
+                hasArgs: true,
+                argName: "description",
+                argDesc: "Task description",
+                required: true,
+            },
+            {
+                name: "exec",
+                description: "Execute shell command",
+                hasArgs: true,
+                argName: "command",
+                argDesc: "Shell command to run",
+                required: true,
+            },
             { name: "stop", description: "Stop running ralph process", hasArgs: false },
             { name: "help", description: "Show help", hasArgs: false },
-            { name: "action", description: "Run daemon action", hasArgs: true, argName: "name", argDesc: "Action name" },
-            { name: "claude", description: "Run Claude Code with prompt", hasArgs: true, argName: "prompt", argDesc: "Prompt for Claude Code", required: true },
+            {
+                name: "action",
+                description: "Run daemon action",
+                hasArgs: true,
+                argName: "name",
+                argDesc: "Action name",
+            },
+            {
+                name: "claude",
+                description: "Run Claude Code with prompt",
+                hasArgs: true,
+                argName: "prompt",
+                argDesc: "Prompt for Claude Code",
+                required: true,
+            },
         ];
         const slashCommands = commands.map((cmd) => {
-            const builder = new SlashCommandBuilder()
-                .setName(cmd.name)
-                .setDescription(cmd.description);
+            const builder = new SlashCommandBuilder().setName(cmd.name).setDescription(cmd.description);
             if (cmd.hasArgs && cmd.argName) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 builder.addStringOption((option) => option
@@ -151,7 +303,7 @@ export class DiscordChatClient {
         // Ignore messages from bots (including self)
         if (message.author?.bot)
             return;
-        // Check if guild is allowed
+        // Check if guild is allowed (null guild is ok for DMs)
         if (!this.isGuildAllowed(message.guild?.id)) {
             if (this.debug) {
                 console.log(`[discord] Ignoring message from unauthorized guild: ${message.guild?.id}`);
@@ -165,7 +317,22 @@ export class DiscordChatClient {
             }
             return;
         }
-        const chatMessage = this.toMessage(message);
+        // Check if bot is mentioned or if this is a DM
+        const isMention = this.isBotMentioned(message);
+        const isDM = this.isDMChannel(message);
+        // Clean the message text (remove bot mention if present)
+        let messageText = message.content || "";
+        if (isMention) {
+            messageText = this.removeBotMention(messageText);
+        }
+        const chatMessage = {
+            text: messageText,
+            chatId: message.channel.id,
+            senderId: message.author?.id,
+            senderName: message.author?.username,
+            timestamp: message.createdAt || new Date(),
+            raw: message,
+        };
         // Call raw message handler if provided
         if (this.onMessage) {
             try {
@@ -177,11 +344,12 @@ export class DiscordChatClient {
                 }
             }
         }
-        // Try to parse as a command
-        const command = parseCommand(chatMessage.text, chatMessage);
+        // Try to parse as a command first
+        const command = parseCommand(messageText, chatMessage);
         if (command && this.onCommand) {
             try {
                 await this.onCommand(command);
+                return; // Command handled, don't process as responder message
             }
             catch (err) {
                 if (this.debug) {
@@ -194,6 +362,45 @@ export class DiscordChatClient {
                 catch {
                     // Ignore reply errors
                 }
+                return;
+            }
+        }
+        // For non-command messages, route through responders
+        // In guilds (servers): only respond if bot is mentioned
+        // In DMs: always respond if responders are configured
+        const shouldProcessAsResponder = isDM || isMention;
+        if (shouldProcessAsResponder && this.responderMatcher) {
+            // Check if there's a matching responder or a default responder
+            const match = this.responderMatcher.matchResponder(messageText);
+            if (match) {
+                try {
+                    const handled = await this.handleResponderMessage(message, messageText);
+                    if (handled) {
+                        return;
+                    }
+                }
+                catch (err) {
+                    if (this.debug) {
+                        console.error(`[discord] Responder error: ${err}`);
+                    }
+                    try {
+                        await message.reply(`Error processing message: ${err instanceof Error ? err.message : "Unknown error"}`);
+                    }
+                    catch {
+                        // Ignore reply errors
+                    }
+                    return;
+                }
+            }
+            else if (isMention && !this.responderMatcher.hasDefaultResponder()) {
+                // Bot was mentioned but no responder matched and no default responder
+                // Send a helpful message
+                try {
+                    await message.reply("I received your message, but no responders are configured. Use `/help` for available commands.");
+                }
+                catch {
+                    // Ignore reply errors
+                }
             }
         }
     }
@@ -389,8 +596,10 @@ export class DiscordChatClient {
                 }, 30000);
                 this.client.once("ready", async () => {
                     clearTimeout(timeout);
+                    // Store bot user ID for mention detection
+                    this.botUserId = this.client.user?.id || null;
                     if (this.debug) {
-                        console.log(`[discord] Connected as ${this.client.user?.tag} (ID: ${this.client.user?.id})`);
+                        console.log(`[discord] Connected as ${this.client.user?.tag} (ID: ${this.botUserId})`);
                     }
                     // Register slash commands after login
                     await this.registerSlashCommands();
@@ -433,7 +642,11 @@ export class DiscordChatClient {
             content: text.substring(0, 2000), // Discord has 2000 char limit
         };
         // Convert inline keyboard to Discord buttons
-        if (options?.inlineKeyboard && options.inlineKeyboard.length > 0 && ActionRowBuilder && ButtonBuilder && ButtonStyle) {
+        if (options?.inlineKeyboard &&
+            options.inlineKeyboard.length > 0 &&
+            ActionRowBuilder &&
+            ButtonBuilder &&
+            ButtonStyle) {
             const components = [];
             for (const row of options.inlineKeyboard) {
                 const actionRow = new ActionRowBuilder();

package/dist/providers/slack.d.ts

@@ -5,7 +5,13 @@
  * Required packages (must be installed separately):
  *   npm install @slack/bolt @slack/web-api
  */
-import { ChatClient, ChatCommandHandler, ChatMessageHandler, SlackSettings, SendMessageOptions } from "../utils/chat-client.js";
+import { ChatClient, ChatCommandHandler, ChatMessage, ChatMessageHandler, SlackSettings, SendMessageOptions } from "../utils/chat-client.js";
+import { ResponderMatch } from "../utils/responder.js";
+/**
+ * Callback for handling responder matches.
+ * Returns the response text to send back to the channel.
+ */
+export type ResponderHandler = (match: ResponderMatch, message: ChatMessage) => Promise<string | null>;
 export declare class SlackChatClient implements ChatClient {
     readonly provider: "slack";
     private settings;
@@ -15,7 +21,41 @@ export declare class SlackChatClient implements ChatClient {
     private webClient;
     private onCommand;
     private onMessage;
+    private responderMatcher;
+    private respondersConfig;
+    private botUserId;
+    private threadConversations;
     constructor(settings: SlackSettings, debug?: boolean);
+    /**
+     * Initialize responder matching from config.
+     */
+    private initializeResponders;
+    /**
+     * Fetch thread context (previous messages in the thread).
+     * Returns formatted context string or empty string if not in a thread.
+     */
+    private fetchThreadContext;
+    /**
+     * Execute a responder and return the result.
+     */
+    private executeResponder;
+    /**
+     * Handle a message that might match a responder or continue an existing thread conversation.
+     * Returns true if a responder was matched and executed.
+     */
+    private handleResponderMessage;
+    /**
+     * Continue an existing thread conversation with the LLM.
+     */
+    private continueThreadConversation;
+    /**
+     * Check if a message is mentioning the bot.
+     */
+    private isBotMentioned;
+    /**
+     * Remove bot mention from message text.
+     */
+    private removeBotMention;
     /**
      * Check if a channel ID is allowed.
      */