ralph-cli-sandboxed 0.4.1 → 0.4.2

package/dist/providers/slack.js

@@ -6,6 +6,11 @@
  *   npm install @slack/bolt @slack/web-api
  */
 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";
 // Dynamic imports for @slack/bolt and @slack/web-api
 // These packages may not be installed in all environments
 let AppConstructor = null;
@@ -34,9 +39,238 @@ export class SlackChatClient {
     webClient = null;
     onCommand = null;
     onMessage = null;
+    responderMatcher = null;
+    respondersConfig = null;
+    botUserId = null;
+    // Track active thread conversations for multi-turn chat
+    threadConversations = new Map();
     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(`[slack] Initialized ${Object.keys(config.chat.responders).length} responders`);
+                }
+            }
+        }
+        catch {
+            // Config not available or responders not configured
+            if (this.debug) {
+                console.log("[slack] No responders configured");
+            }
+        }
+    }
+    /**
+     * Fetch thread context (previous messages in the thread).
+     * Returns formatted context string or empty string if not in a thread.
+     */
+    async fetchThreadContext(channelId, threadTs, currentMessageTs) {
+        if (!this.webClient)
+            return "";
+        try {
+            // Fetch thread replies
+            const result = await this.webClient.conversations.replies({
+                channel: channelId,
+                ts: threadTs,
+                limit: 10, // Get last 10 messages in thread
+            });
+            if (!result.messages || result.messages.length <= 1) {
+                return ""; // No thread context (only the parent message or current message)
+            }
+            // Format thread messages, excluding the current message and bot messages
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const contextMessages = result.messages
+                .filter((msg) => {
+                // Exclude current message and bot messages
+                if (msg.ts === currentMessageTs)
+                    return false;
+                if (msg.bot_id || msg.subtype === "bot_message")
+                    return false;
+                return true;
+            })
+                .map((msg) => {
+                const text = msg.text || "[no text]";
+                return `---\n${text}`;
+            });
+            if (contextMessages.length === 0) {
+                return "";
+            }
+            return `Previous messages in thread:\n${contextMessages.join("\n")}\n---\n\nCurrent request:\n`;
+        }
+        catch (err) {
+            if (this.debug) {
+                console.error(`[slack] Failed to fetch thread context: ${err}`);
+            }
+            return "";
+        }
+    }
+    /**
+     * Execute a responder and return the result.
+     */
+    async executeResponder(match, message, threadContext) {
+        const { responder } = match;
+        // Prepend thread context if available
+        const fullMessage = threadContext ? threadContext + message : message;
+        switch (responder.type) {
+            case "llm":
+                return executeLLMResponder(fullMessage, responder, undefined, {
+                    responderName: match.name,
+                    trigger: responder.trigger,
+                    threadContextLength: threadContext?.length,
+                    debug: this.debug,
+                });
+            case "claude-code":
+                return executeClaudeCodeResponder(fullMessage, responder);
+            case "cli":
+                return executeCLIResponder(message, responder); // CLI doesn't use thread context
+            default:
+                return {
+                    success: false,
+                    response: "",
+                    error: `Unknown responder type: ${responder.type}`,
+                };
+        }
+    }
+    /**
+     * Handle a message that might match a responder or continue an existing thread conversation.
+     * Returns true if a responder was matched and executed.
+     */
+    async handleResponderMessage(message, say, threadTs, messageTs) {
+        // Check if this is a continuation of an existing thread conversation
+        if (threadTs) {
+            const existingConversation = this.threadConversations.get(threadTs);
+            if (existingConversation) {
+                if (this.debug) {
+                    console.log(`[slack] Continuing thread conversation with ${existingConversation.responderName}`);
+                }
+                return this.continueThreadConversation(existingConversation, threadTs, message.text, say);
+            }
+        }
+        if (!this.responderMatcher) {
+            return false;
+        }
+        if (this.debug) {
+            console.log(`[slack] Checking responders for message: "${message.text.slice(0, 50)}..."`);
+        }
+        const match = this.responderMatcher.matchResponder(message.text);
+        if (!match) {
+            if (this.debug) {
+                console.log(`[slack] No responder matched for message`);
+            }
+            return false;
+        }
+        if (this.debug) {
+            console.log(`[slack] Matched responder: ${match.name} (type: ${match.responder.type})`);
+        }
+        // For LLM responders, start a new thread conversation
+        const userMessage = match.args || message.text;
+        const result = await this.executeResponder(match, userMessage, undefined);
+        // Send the response (use thread_ts for context continuity)
+        const responseThreadTs = threadTs || messageTs;
+        if (result.success) {
+            await say({
+                text: result.response,
+                thread_ts: responseThreadTs,
+            });
+            // Start tracking this thread conversation for LLM responders
+            if (match.responder.type === "llm" && responseThreadTs) {
+                this.threadConversations.set(responseThreadTs, {
+                    responderName: match.name,
+                    responder: match.responder,
+                    messages: [
+                        { role: "user", content: userMessage, timestamp: messageTs || "" },
+                        { role: "assistant", content: result.response, timestamp: new Date().toISOString() },
+                    ],
+                    createdAt: new Date(),
+                });
+                if (this.debug) {
+                    console.log(`[slack] Started thread conversation for ${responseThreadTs}`);
+                }
+            }
+        }
+        else {
+            const errorMsg = result.error
+                ? `Error: ${result.error}`
+                : "An error occurred while processing your message.";
+            await say({
+                text: errorMsg,
+                thread_ts: responseThreadTs,
+            });
+        }
+        return true;
+    }
+    /**
+     * Continue an existing thread conversation with the LLM.
+     */
+    async continueThreadConversation(conversation, threadTs, userMessage, say) {
+        // Build conversation history for the LLM
+        const conversationHistory = conversation.messages.map((msg) => ({
+            role: msg.role,
+            content: msg.content,
+        }));
+        if (this.debug) {
+            console.log(`[slack] Conversation history: ${conversationHistory.length} messages`);
+        }
+        // Execute responder with conversation history
+        const result = await executeLLMResponder(userMessage, conversation.responder, undefined, {
+            responderName: conversation.responderName,
+            trigger: conversation.responder.trigger,
+            conversationHistory,
+            debug: this.debug,
+        });
+        if (result.success) {
+            await say({
+                text: result.response,
+                thread_ts: threadTs,
+            });
+            // Add messages to conversation history
+            conversation.messages.push({ role: "user", content: userMessage, timestamp: new Date().toISOString() }, { role: "assistant", content: result.response, timestamp: new Date().toISOString() });
+            // Limit conversation history to prevent token overflow (keep last 20 messages)
+            if (conversation.messages.length > 20) {
+                conversation.messages = conversation.messages.slice(-20);
+            }
+        }
+        else {
+            const errorMsg = result.error
+                ? `Error: ${result.error}`
+                : "An error occurred while processing your message.";
+            await say({
+                text: errorMsg,
+                thread_ts: threadTs,
+            });
+        }
+        return true;
+    }
+    /**
+     * Check if a message is mentioning the bot.
+     */
+    isBotMentioned(text) {
+        if (!this.botUserId) {
+            return false;
+        }
+        // Check for <@USERID> format used by Slack
+        return text.includes(`<@${this.botUserId}>`);
+    }
+    /**
+     * Remove bot mention from message text.
+     */
+    removeBotMention(text) {
+        if (!this.botUserId) {
+            return text;
+        }
+        // Remove <@USERID> and any surrounding whitespace
+        return text.replace(new RegExp(`<@${this.botUserId}>\\s*`, "g"), "").trim();
     }
     /**
      * Check if a channel ID is allowed.
@@ -66,14 +300,91 @@ export class SlackChatClient {
     setupEventHandlers() {
         if (!this.app)
             return;
+        // Add global error handler
+        this.app.error(async (error) => {
+            console.error("[slack] App error:", error);
+        });
+        // Log all incoming events when debug is enabled
+        if (this.debug) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.app.use(async ({ payload, next }) => {
+                const eventType = payload?.type || payload?.event?.type || "unknown";
+                console.log(`[slack] Event received: ${eventType}`);
+                await next();
+            });
+        }
+        // Handle app_mention events (when someone @mentions the bot)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.app.event("app_mention", async ({ event, say, }) => {
+            if (this.debug) {
+                console.log(`[slack] Received app_mention in channel ${event.channel}`);
+            }
+            const channelId = event.channel;
+            // Check if channel is allowed
+            if (!this.isChannelAllowed(channelId)) {
+                if (this.debug) {
+                    console.log(`[slack] Ignoring mention from unauthorized channel: ${channelId}`);
+                }
+                return;
+            }
+            // Remove the bot mention from the message text
+            const cleanedText = this.removeBotMention(event.text || "");
+            const chatMessage = this.toMessage({
+                text: cleanedText,
+                channel: channelId,
+                user: event.user,
+                ts: event.ts || String(Date.now() / 1000),
+            });
+            // Get thread_ts for reply context (use parent thread or message ts)
+            const threadTs = event.thread_ts || event.ts;
+            // Try responder matching first
+            try {
+                const handled = await this.handleResponderMessage(chatMessage, async (opts) => {
+                    if (typeof opts === "string") {
+                        await say({ text: opts, thread_ts: threadTs });
+                    }
+                    else {
+                        await say({ ...opts, thread_ts: threadTs });
+                    }
+                }, threadTs, event.ts);
+                if (handled) {
+                    return;
+                }
+            }
+            catch (err) {
+                if (this.debug) {
+                    console.error(`[slack] Responder error: ${err}`);
+                }
+                await say({
+                    text: `Error processing message: ${err instanceof Error ? err.message : "Unknown error"}`,
+                    thread_ts: threadTs,
+                });
+                return;
+            }
+            // If no responder matched and no default responder, reply with help
+            if (!this.responderMatcher?.hasDefaultResponder()) {
+                await say({
+                    text: "I received your message, but no responders are configured. Use /ralph for commands.",
+                    thread_ts: threadTs,
+                });
+            }
+        });
         // Handle all messages (including DMs and channel messages)
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.app.message(async ({ message, say }) => {
+        this.app.message(async ({ message, say, }) => {
+            // Debug: log raw message event before any filtering
+            if (this.debug) {
+                console.log(`[slack] Raw message event: channel=${message.channel}, text="${(message.text || "").slice(0, 50)}", subtype=${message.subtype || "none"}, bot_id=${message.bot_id || "none"}`);
+            }
             // Type guard for message with text
             if (!message.text)
                 return;
             if (!message.channel)
                 return;
+            // Ignore bot messages to prevent loops
+            if (message.bot_id || message.subtype === "bot_message") {
+                return;
+            }
             const channelId = message.channel;
             // Check if channel is allowed
             if (!this.isChannelAllowed(channelId)) {
@@ -82,8 +393,17 @@ export class SlackChatClient {
                 }
                 return;
             }
+            // Get thread_ts for reply context (use parent thread or message ts)
+            const threadTs = message.thread_ts || message.ts;
+            // Check if this is a bot mention - if so, process it
+            const isMention = this.isBotMentioned(message.text);
+            // Create chat message
+            let messageText = message.text;
+            if (isMention) {
+                messageText = this.removeBotMention(message.text);
+            }
             const chatMessage = this.toMessage({
-                text: message.text,
+                text: messageText,
                 channel: channelId,
                 user: message.user,
                 ts: message.ts || String(Date.now() / 1000),
@@ -99,18 +419,56 @@ export class SlackChatClient {
                     }
                 }
             }
-            // Try to parse as a command
+            // Try to parse as a command first
             const command = parseCommand(chatMessage.text, chatMessage);
             if (command && this.onCommand) {
                 try {
                     await this.onCommand(command);
+                    return; // Command handled, don't process as responder message
                 }
                 catch (err) {
                     if (this.debug) {
                         console.error(`[slack] Command handler error: ${err}`);
                     }
                     // Send error message to channel
-                    await say(`Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`);
+                    await say({
+                        text: `Error executing command: ${err instanceof Error ? err.message : "Unknown error"}`,
+                        thread_ts: threadTs,
+                    });
+                    return;
+                }
+            }
+            // Check if this is a continuation of an active thread conversation
+            const isActiveThread = threadTs && this.threadConversations.has(threadTs);
+            // If message contains a bot mention, responders are configured, or we're in an active thread,
+            // try to route through responder matching
+            // Note: We try matching whenever responders exist, not just on bot mention,
+            // so that @trigger patterns (like @qa) work without requiring @bot first
+            if (isMention || this.responderMatcher || isActiveThread) {
+                try {
+                    const handled = await this.handleResponderMessage(chatMessage, async (opts) => {
+                        if (typeof opts === "string") {
+                            await say({ text: opts, thread_ts: threadTs });
+                        }
+                        else {
+                            await say({ ...opts, thread_ts: threadTs });
+                        }
+                    }, threadTs, message.ts);
+                    if (handled) {
+                        return;
+                    }
+                }
+                catch (err) {
+                    if (this.debug) {
+                        console.error(`[slack] Responder error: ${err}`);
+                    }
+                    if (isMention || isActiveThread) {
+                        // Reply with error if this was a direct mention or active thread
+                        await say({
+                            text: `Error processing message: ${err instanceof Error ? err.message : "Unknown error"}`,
+                            thread_ts: threadTs,
+                        });
+                    }
                 }
             }
         });
@@ -123,7 +481,7 @@ export class SlackChatClient {
         }
         this.app.command("/ralph", 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        async ({ command, ack, respond }) => {
+        async ({ command, ack, respond, }) => {
             if (this.debug) {
                 console.log(`[slack] Received: /ralph ${command.text} from channel ${command.channel_id}`);
             }
@@ -187,7 +545,7 @@ export class SlackChatClient {
         // Handle button actions (Block Kit interactive components)
         this.app.action(/^ralph_action_.*/, 
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        async ({ action, ack, body, respond }) => {
+        async ({ action, ack, body, respond, }) => {
             await ack();
             if (!action.value)
                 return;
@@ -254,9 +612,28 @@ export class SlackChatClient {
             await this.app.start();
             // Verify connection by checking auth
             const authResult = await this.webClient.auth.test();
-            if (this.debug) {
-                console.log(`[slack] Connected as @${authResult.user} (bot ID: ${authResult.bot_id})`);
+            this.botUserId = authResult.user_id || authResult.bot_id;
+            // Always show connection info
+            console.log(`[slack] Workspace: ${authResult.team || "unknown"} (${authResult.url || ""})`);
+            console.log(`[slack] Bot user: @${authResult.user || "unknown"} (ID: ${this.botUserId})`);
+            if (authResult.app_id) {
+                console.log(`[slack] App ID: ${authResult.app_id}`);
+                console.log(`[slack] Configure at: https://api.slack.com/apps/${authResult.app_id}`);
+            }
+            // Show responder info
+            if (this.respondersConfig) {
+                const responderNames = Object.keys(this.respondersConfig);
+                console.log(`[slack] Responders: ${responderNames.join(", ") || "(none)"}`);
             }
+            else {
+                console.log(`[slack] Responders: (none configured)`);
+            }
+            // Remind about slash command setup
+            console.log(`[slack] `);
+            console.log(`[slack] For /ralph slash command to work:`);
+            console.log(`[slack]   1. Go to Slack App settings → Slash Commands`);
+            console.log(`[slack]   2. Create command: /ralph`);
+            console.log(`[slack]   3. Enable "Escape channels, users, and links" option`);
             this.connected = true;
         }
         catch (err) {
@@ -272,6 +649,10 @@ export class SlackChatClient {
             channel: chatId,
             text, // Fallback text for notifications
         };
+        // Add thread_ts for context continuity if provided
+        if (options?.threadTs) {
+            payload.thread_ts = options.threadTs;
+        }
         // Convert inline keyboard to Slack Block Kit buttons
         if (options?.inlineKeyboard && options.inlineKeyboard.length > 0) {
             const blocks = [];

package/dist/providers/telegram.d.ts

@@ -11,7 +11,37 @@ export declare class TelegramChatClient implements ChatClient {
     private lastUpdateId;
     private pollingTimeout;
     private debug;
+    private responderMatcher;
+    private respondersConfig;
+    private botUserId;
+    private botUsername;
     constructor(settings: TelegramSettings, debug?: boolean);
+    /**
+     * Initialize responder matching from config.
+     */
+    private initializeResponders;
+    /**
+     * Execute a responder and return the result.
+     */
+    private executeResponder;
+    /**
+     * Handle a message that might match a responder.
+     * Returns true if a responder was matched and executed.
+     */
+    private handleResponderMessage;
+    /**
+     * Check if the bot is mentioned in a message.
+     * Handles both @username mentions and direct replies to the bot.
+     */
+    private isBotMentioned;
+    /**
+     * Remove bot mention from message text.
+     */
+    private removeBotMention;
+    /**
+     * Check if a chat is a group chat (group or supergroup).
+     */
+    private isGroupChat;
     /**
      * Make a request to the Telegram Bot API.
      */