gibi-bot 1.0.0

package/src/app.ts

@@ -0,0 +1,809 @@
+#!/usr/bin/env node
+import { App } from '@slack/bolt';
+import { loadConfig, clearConfig } from './config';
+import { ContextManager } from './context';
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { PLAN_MODE_PROMPT } from './prompts';
+import { agentRegistry } from './agents';
+
+
+const AVAILABLE_MODELS = [
+  { id: 'gemini-2.5-pro', desc: 'Complex reasoning, coding (Access required)' },
+  { id: 'gemini-2.5-flash', desc: 'Fast, lightweight (Access required)' },
+  { id: 'gemini-1.5-pro', desc: 'General purpose, good reasoning' },
+  { id: 'gemini-1.5-flash', desc: 'High speed, lower latency' },
+  { id: 'gemini-1.0-pro', desc: 'Standard model' },
+];
+
+
+
+
+let isRestarting = false;
+
+const start = async () => {
+  try {
+    await loadConfig();
+
+    let BOT_USER_ID = '';
+    let BOT_ID = '';
+
+    const app = new App({
+      token: process.env.SLACK_BOT_TOKEN || '',
+      signingSecret: process.env.SLACK_SIGNING_SECRET || '',
+      socketMode: true,
+      appToken: process.env.SLACK_APP_TOKEN || ''
+    });
+
+    // Fetch Bot User ID on startup
+    (async () => {
+      try {
+        const authResult = await app.client.auth.test();
+        BOT_USER_ID = authResult.user_id as string;
+        BOT_ID = authResult.bot_id as string;
+      } catch (e) {
+        console.error('Failed to fetch Bot User ID:', e);
+      }
+    })();
+
+    const contextManager = new ContextManager();
+
+    // Handle bot being added to a channel
+    app.event('member_joined_channel', async ({ event, client, say }) => {
+      // Use cached ID or fetch if not ready
+      if (!BOT_USER_ID) {
+        const authResult = await client.auth.test();
+        BOT_USER_ID = authResult.user_id as string;
+        BOT_ID = authResult.bot_id as string;
+      }
+
+      if (event.user === BOT_USER_ID) {
+        await say(`Hello! I'm Gibi. I'm ready to help. Mention me (@Gibi) to start a new thread!`);
+      }
+    });
+
+    // Generic message handler for Agent Chat
+    // Helper to handle Agent turns
+    const processAgentTurn = async (
+      contextId: string,
+      channelId: string,
+      threadTs: string | undefined,
+      userText: string | undefined,
+      say: any,
+      client: any,
+      existingMessageTs?: string
+    ) => {
+      const context = contextManager.getContext(contextId);
+
+      // Append User Message if provided
+      if (userText) {
+        context.messages.push({ role: 'user', content: userText });
+        contextManager.setContextData(contextId, { messages: context.messages });
+      }
+
+      let processingMsgTs: string | undefined = existingMessageTs;
+
+      try {
+        const agentName = context.data.agent || 'gemini';
+
+        // Send or Update ephemeral "Thinking..." message
+        const thinkingBlocks = [
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `_Thinking..._ (using \`${agentName}\`)`
+            }
+          }
+        ];
+
+        if (processingMsgTs) {
+          await client.chat.update({
+            channel: channelId,
+            ts: processingMsgTs,
+            text: 'Thinking...',
+            blocks: thinkingBlocks
+          });
+        } else {
+          const processingMsg = await say({
+            blocks: thinkingBlocks,
+            text: 'Thinking...',
+            thread_ts: threadTs
+          });
+          processingMsgTs = processingMsg.ts as string;
+        }
+
+        // Determine Agent
+        const agent = agentRegistry[agentName];
+
+        if (!agent) {
+          throw new Error(`Unknown agent: ${agentName}`);
+        }
+
+        const responseText = await agent.run(context.messages, {
+          model: context.data.model,
+          mode: context.data.mode
+        });
+
+        if (responseText) {
+          // Append Assistant Response
+          context.messages.push({ role: 'assistant', content: responseText });
+          contextManager.setContextData(contextId, { messages: context.messages });
+
+          const responseBlocks = [
+            {
+              type: 'section',
+              text: {
+                type: 'mrkdwn',
+                text: responseText
+              }
+            },
+            {
+              type: 'context',
+              elements: [
+                {
+                  type: 'mrkdwn',
+                  text: `🤖 *Agent:* \`${agentName}\` | 🧠 *Model:* \`${context.data.model || 'default'}\` | 📂 *CWD:* \`${context.data.cwd || 'root'}\``
+                }
+              ]
+            },
+            {
+              type: 'actions',
+              elements: [
+                {
+                  type: 'button',
+                  text: { type: 'plain_text', text: '🔄 Retry', emoji: true },
+                  action_id: 'retry_turn'
+                },
+                {
+                  type: 'button',
+                  text: { type: 'plain_text', text: '↩️ Revert', emoji: true },
+                  action_id: 'revert_turn'
+                }
+              ]
+            }
+          ];
+
+          // Update the processing message with the actual response
+          if (processingMsgTs) {
+            await client.chat.update({
+              channel: channelId,
+              ts: processingMsgTs,
+              text: responseText,
+              blocks: responseBlocks
+            });
+          } else {
+            await say({
+              text: responseText,
+              blocks: responseBlocks,
+              thread_ts: threadTs
+            });
+          }
+        } else if (processingMsgTs) {
+          // Handle empty response case
+          await client.chat.update({
+            channel: channelId,
+            ts: processingMsgTs,
+            text: `Received empty response from ${agentName}.`
+          });
+        }
+
+      } catch (error: any) {
+        console.error('Error calling Agent:', error);
+        const errorMessage = `params: Error calling Agent: ${error.message}`;
+
+        if (processingMsgTs) {
+          await client.chat.update({
+            channel: channelId,
+            ts: processingMsgTs,
+            text: errorMessage
+          });
+        } else {
+          await say({
+            text: errorMessage,
+            thread_ts: threadTs
+          });
+        }
+      }
+    };
+
+    // Handle generic messages
+    app.message(async ({ message, say, client }) => {
+      const msg = message as any;
+      if (msg.bot_id || msg.subtype === 'bot_message' || !msg.text) return;
+
+      // Skip if it looks like the cd command
+      if (/^cd\s+/.test(msg.text.trim())) return;
+
+      // Check if this message mentions the bot
+      let isMention = false;
+      if (BOT_USER_ID && msg.text.includes(`<@${BOT_USER_ID}>`)) isMention = true;
+      if (BOT_ID && msg.text.includes(`<@${BOT_ID}>`)) isMention = true;
+
+      const isDm = msg.channel_type === 'im';
+      const isThread = !!msg.thread_ts;
+
+      const contextId = msg.thread_ts || msg.channel;
+
+      if (isDm) {
+        // Process
+      } else if (isThread) {
+        if (!isMention && !contextManager.hasContext(contextId)) return;
+      } else {
+        if (!isMention) return;
+      }
+
+      // Clean up text (remove mention)
+      let text = msg.text;
+      if (BOT_USER_ID) text = text.replace(new RegExp(`<@${BOT_USER_ID}>`, 'g'), '').trim();
+      if (BOT_ID) text = text.replace(new RegExp(`<@${BOT_ID}>`, 'g'), '').trim();
+
+      const replyThreadTs = msg.thread_ts || msg.ts;
+      const targetContextId = msg.thread_ts || msg.ts;
+
+      await processAgentTurn(targetContextId, msg.channel, replyThreadTs, text, say, client);
+    });
+
+    // Helper for CD command (shared between Slash command and Message)
+    const executeChangeDirectory = async (contextId: string, targetPath: string): Promise<any> => {
+      const context = contextManager.getContext(contextId);
+
+      // 1. Determine current context CWD
+      const currentCwd = context.data.cwd || process.cwd();
+
+      // 2. Resolve new path
+      let newPath = currentCwd;
+      if (targetPath) {
+        newPath = path.resolve(currentCwd, targetPath);
+      }
+
+      try {
+        // 3. Validate path
+        await fs.promises.access(newPath, fs.constants.F_OK);
+        const stats = await fs.promises.stat(newPath);
+
+        if (!stats.isDirectory()) {
+          return { text: `❌ Path is not a directory: \`${newPath}\`` };
+        }
+
+        // 4. Update Context
+        contextManager.setContextData(contextId, { cwd: newPath });
+
+        // 5. List files
+        const files = await fs.promises.readdir(newPath, { withFileTypes: true });
+
+        // Sort: Directories first, then files
+        files.sort((a, b) => {
+          if (a.isDirectory() && !b.isDirectory()) return -1;
+          if (!a.isDirectory() && b.isDirectory()) return 1;
+          return a.name.localeCompare(b.name);
+        });
+
+        // Build Blocks
+        const blocks: any[] = [
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `📂 *Directory:* \`${newPath}\``
+            }
+          }
+        ];
+
+        // Add "Up" button if not root
+        const parentPath = path.dirname(newPath);
+        if (newPath !== parentPath) {
+          blocks.push({
+            type: 'actions',
+            elements: [
+              {
+                type: 'button',
+                text: {
+                  type: 'plain_text',
+                  text: '⬆️ Up one level',
+                  emoji: true
+                },
+                value: parentPath,
+                action_id: 'navigate_dir'
+              }
+            ]
+          });
+        }
+
+        const dirButtons: any[] = [];
+        const fileNames: string[] = [];
+
+        files.forEach(file => {
+          if (file.isDirectory()) {
+            if (dirButtons.length < 10) { // Limit buttons to avoid clutter
+              dirButtons.push({
+                type: 'button',
+                text: {
+                  type: 'plain_text',
+                  text: `📁 ${file.name}`,
+                  emoji: true
+                },
+                value: path.join(newPath, file.name),
+                action_id: 'navigate_dir'
+              });
+            } else {
+              fileNames.push(`📁 ${file.name}`);
+            }
+          } else {
+            fileNames.push(`📄 ${file.name}`);
+          }
+        });
+
+        if (dirButtons.length > 0) {
+          // Slack allows max 5 buttons per action block
+          for (let i = 0; i < dirButtons.length; i += 5) {
+            blocks.push({
+              type: 'actions',
+              elements: dirButtons.slice(i, i + 5)
+            });
+          }
+        }
+
+        if (fileNames.length > 0) {
+          let fileListText = fileNames.join('\n');
+          if (fileListText.length > 2500) {
+            fileListText = fileListText.substring(0, 2500) + '\n...(truncated)';
+          }
+          blocks.push({
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: fileListText
+            }
+          });
+        }
+
+        return {
+          text: `Directory: ${newPath}`,
+          blocks: blocks
+        };
+
+      } catch (error: any) {
+        return { text: `❌ Error accessing directory: ${error.message}` };
+      }
+    };
+
+    // Handle navigate_dir action
+    app.action('navigate_dir', async ({ ack, body, respond }) => {
+      await ack();
+      const action = (body as any).actions[0];
+      const contextId = (body as any).container.thread_ts || (body as any).container.channel_id;
+
+      const output = await executeChangeDirectory(contextId, action.value);
+      await respond({
+        ...output,
+        replace_original: true
+      });
+    });
+
+    // Handle /plan command
+    app.command('/plan', async ({ command, ack, say, client }) => {
+      await ack();
+      const contextId = command.channel_id;
+      const goal = command.text.trim();
+
+      // Switch to Plan Mode
+      contextManager.setContextData(contextId, { mode: 'plan' });
+
+      // Notify initiation
+      await say({
+        text: `📝 *Entering Plan Mode*\nTarget: ${goal || "No specific goal provided. What would you like to plan?"}`,
+        channel: command.channel_id
+      });
+
+      // If goal provided, process it as the first message
+      if (goal) {
+        await processAgentTurn(contextId, command.channel_id, undefined, goal, say, client);
+      }
+    });
+
+    // Handle /cd command
+    app.command('/cd', async ({ command, ack, respond }) => {
+      await ack();
+      const output = await executeChangeDirectory(command.channel_id, command.text.trim());
+      await respond(output);
+    });
+
+    // Handle "cd [path]" messages (works in threads)
+    app.message(/^cd\s+(.+)/, async ({ message, context, say }) => {
+      // Need to cast message to access optional properties like thread_ts
+      const msg = message as any;
+      const targetPath = context.matches[1].trim();
+
+      // Use thread_ts if available, otherwise channel
+      const contextId = msg.thread_ts || msg.channel;
+
+      const output = await executeChangeDirectory(contextId, targetPath);
+
+      await say({
+        text: output,
+        thread_ts: msg.thread_ts // Reply in thread if it was a thread message
+      });
+    });
+
+    // Handle /model command
+    app.command('/model', async ({ command, ack, client, respond }) => {
+      await ack();
+      const input = command.text.trim();
+      const contextId = command.channel_id;
+
+      const context = contextManager.getContext(contextId);
+
+      // Show modal if no input
+      if (!input) {
+        await client.views.open({
+          trigger_id: command.trigger_id,
+          view: {
+            type: 'modal',
+            callback_id: 'model_select_modal',
+            private_metadata: contextId,
+            title: { type: 'plain_text', text: 'Select Model' },
+            blocks: [
+              {
+                type: 'input',
+                block_id: 'model_block',
+                label: { type: 'plain_text', text: 'Choose a Gemini model' },
+                element: {
+                  type: 'static_select',
+                  action_id: 'model_select',
+                  initial_option: AVAILABLE_MODELS.find(m => m.id === (context.data.model || 'gemini-1.5-pro')) ? {
+                    text: { type: 'plain_text', text: context.data.model || 'gemini-1.5-pro' },
+                    value: context.data.model || 'gemini-1.5-pro'
+                  } : undefined,
+                  options: AVAILABLE_MODELS.map(m => ({
+                    text: { type: 'plain_text', text: m.id },
+                    value: m.id,
+                    description: { type: 'plain_text', text: m.desc.substring(0, 75) }
+                  }))
+                }
+              }
+            ],
+            submit: { type: 'plain_text', text: 'Update' }
+          }
+        });
+        return;
+      }
+
+      if (input === 'list' || input === 'help') {
+        const currentModel = context.data.model || 'default';
+        const modelList = AVAILABLE_MODELS.map(m => `• \`${m.id}\`: ${m.desc}`).join('\n');
+
+        await respond(
+          `Current model: \`${currentModel}\`\n\n` +
+          `*Available Models:*\n${modelList}\n\n` +
+          `To switch, use \`/model <model_name>\``
+        );
+        return;
+      }
+
+      contextManager.setContextData(contextId, { model: input });
+      await respond(`Switched model to: \`${input}\``);
+    });
+
+    // Handle /agent command
+    app.command('/agent', async ({ command, ack, client, respond }) => {
+      await ack();
+      const input = command.text.trim();
+      const contextId = command.channel_id;
+
+      const context = contextManager.getContext(contextId);
+
+      if (!input) {
+        await client.views.open({
+          trigger_id: command.trigger_id,
+          view: {
+            type: 'modal',
+            callback_id: 'agent_select_modal',
+            private_metadata: contextId,
+            title: { type: 'plain_text', text: 'Select Agent' },
+            blocks: [
+              {
+                type: 'input',
+                block_id: 'agent_block',
+                label: { type: 'plain_text', text: 'Choose a backing agent' },
+                element: {
+                  type: 'static_select',
+                  action_id: 'agent_select',
+                  initial_option: {
+                    text: { type: 'plain_text', text: context.data.agent || 'gemini' },
+                    value: context.data.agent || 'gemini'
+                  },
+                  options: Object.keys(agentRegistry).map(k => ({
+                    text: { type: 'plain_text', text: k },
+                    value: k
+                  }))
+                }
+              }
+            ],
+            submit: { type: 'plain_text', text: 'Update' }
+          }
+        });
+        return;
+      }
+
+      if (input === 'list' || input === 'help') {
+        const currentAgent = context.data.agent || 'gemini';
+        const agentList = Object.keys(agentRegistry).map(k => `• \`${k}\``).join('\n');
+
+        await respond(
+          `Current agent: \`${currentAgent}\`\n\n` +
+          `*Available Agents:*\n${agentList}\n\n` +
+          `To switch, use \`/agent <agent_name>\``
+        );
+        return;
+      }
+
+      const agentName = input.toLowerCase();
+      if (!agentRegistry[agentName]) {
+        await respond(`❌ Unknown agent: \`${agentName}\`. Available agents: ${Object.keys(agentRegistry).join(', ')}`);
+        return;
+      }
+
+      contextManager.setContextData(contextId, { agent: agentName });
+      await respond(`Switched agent to: \`${agentName}\``);
+    });
+
+    // Handle Modal Submissions
+    app.view('model_select_modal', async ({ ack, view, client }) => {
+      await ack();
+      const contextId = view.private_metadata;
+      const selectedModel = view.state.values.model_block.model_select.selected_option?.value;
+
+      if (selectedModel) {
+        contextManager.setContextData(contextId, { model: selectedModel });
+        await client.chat.postMessage({
+          channel: contextId,
+          text: `🔄 Model updated to \`${selectedModel}\``
+        });
+      }
+    });
+
+    app.view('agent_select_modal', async ({ ack, view, client }) => {
+      await ack();
+      const contextId = view.private_metadata;
+      const selectedAgent = view.state.values.agent_block.agent_select.selected_option?.value;
+
+      if (selectedAgent) {
+        contextManager.setContextData(contextId, { agent: selectedAgent });
+        await client.chat.postMessage({
+          channel: contextId,
+          text: `🔄 Agent updated to \`${selectedAgent}\``
+        });
+      }
+    });
+
+    // Handle Retry
+    app.action('retry_turn', async ({ ack, body, client }) => {
+      await ack();
+      const action = (body as any);
+      const contextId = action.container.thread_ts || action.container.channel_id;
+      const channelId = action.container.channel_id;
+      const messageTs = action.container.message_ts;
+      const threadTs = action.container.thread_ts;
+
+      const context = contextManager.getContext(contextId);
+
+      // Remove last assistant message
+      if (context.messages.length > 0 && context.messages[context.messages.length - 1].role === 'assistant') {
+        context.messages.pop();
+      }
+
+      // Add a note to the last user message if not already present
+      if (context.messages.length > 0 && context.messages[context.messages.length - 1].role === 'user') {
+        const lastMsg = context.messages[context.messages.length - 1];
+        if (!lastMsg.content.includes('[System: The user requested a retry')) {
+          lastMsg.content += '\n\n[System: The user requested a retry of this instruction.]';
+        }
+      }
+
+      contextManager.setContextData(contextId, { messages: context.messages });
+
+      // Polyfill say using client
+      const say = async (args: any) => {
+        const msg = typeof args === 'string' ? { text: args } : args;
+        return await client.chat.postMessage({
+          channel: channelId,
+          ...msg
+        });
+      };
+
+      // Re-run agent turn (without new user text, using existing message to update)
+      await processAgentTurn(contextId, channelId, threadTs, undefined, say, client, messageTs);
+    });
+
+    // Handle Revert
+    app.action('revert_turn', async ({ ack, body, client }) => {
+      await ack();
+      const action = (body as any);
+      const contextId = action.container.thread_ts || action.container.channel_id;
+      const channelId = action.container.channel_id;
+      const threadTs = action.container.thread_ts;
+
+      const context = contextManager.getContext(contextId);
+
+      // Find the last user message to include in the revert prompt
+      let lastUserText = '';
+      for (let i = context.messages.length - 1; i >= 0; i--) {
+        if (context.messages[i].role === 'user') {
+          lastUserText = context.messages[i].content;
+          break;
+        }
+      }
+
+      // Polyfill say using client
+      const say = async (args: any) => {
+        const msg = typeof args === 'string' ? { text: args } : args;
+        return await client.chat.postMessage({
+          channel: channelId,
+          ...msg
+        });
+      };
+
+      const revertPrompt = `The user wants to revert the actions taken for the following request: "${lastUserText}". Please undo any file modifications or state changes made in that turn.`;
+
+      // Trigger a new turn with instructions to revert
+      // We do NOT pop messages here, we want the agent to see what it did and undo it.
+      await processAgentTurn(
+        contextId,
+        channelId,
+        threadTs,
+        revertPrompt,
+        say,
+        client
+      );
+    });
+
+    // Handle /help command
+    app.command('/help', async ({ ack, respond }) => {
+      await ack();
+      const helpMessage = `
+    *Available Commands:*
+    
+    - \`/plan [goal]\`: Enter plan mode to generate and execute coding plans.
+    - \`/cd [path]\`: Change the current working directory for the conversation.
+    - \`/model [name]\`: Switch the Gemini model (e.g., \`gemini-pro\`, \`gemini-1.5-pro\`).
+    - \`/agent [name]\`: Switch the backing agent (e.g., \`gemini\`, \`claude\`, \`cursor\`).
+    - \`/help\`: Show this help message.
+          `;
+      await respond(helpMessage);
+    });
+
+    // Handle App Home Tab
+    app.event('app_home_opened', async ({ event, client, logger }) => {
+      try {
+        const contexts = contextManager.getAllContexts();
+        // Sort by last active
+        contexts.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+
+        const contextBlocks = contexts.slice(0, 5).map(ctx => ({
+          type: 'section',
+          text: {
+            type: 'mrkdwn',
+            text: `*Context:* \`${ctx.id}\`\n*Last Active:* ${ctx.lastActiveAt.toLocaleString()}\n*Agent:* \`${ctx.data.agent || 'gemini'}\` | *Model:* \`${ctx.data.model || 'default'}\` | *CWD:* \`${ctx.data.cwd || 'root'}\``
+          }
+        }));
+
+        const blocks: any[] = [
+          {
+            type: 'header',
+            text: {
+              type: 'plain_text',
+              text: '🏠 Gibi Dashboard',
+              emoji: true
+            }
+          },
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: `Welcome, <@${event.user}>! Here is a summary of your Gibi instance status.`
+            }
+          },
+          {
+            type: 'divider'
+          },
+          {
+            type: 'section',
+            fields: [
+              {
+                type: 'mrkdwn',
+                text: `*Default Agent:*\n\`gemini\``
+              },
+              {
+                type: 'mrkdwn',
+                text: `*Available Agents:*\n${Object.keys(agentRegistry).map(k => `\`${k}\``).join(', ')}`
+              }
+            ]
+          },
+          {
+            type: 'divider'
+          },
+          {
+            type: 'header',
+            text: {
+              type: 'plain_text',
+              text: '🕒 Recent Activity',
+              emoji: true
+            }
+          }
+        ];
+
+        if (contextBlocks.length > 0) {
+          blocks.push(...contextBlocks.flatMap(b => [b, { type: 'divider' }]));
+        } else {
+          blocks.push({
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: '_No active contexts found. Send a message to Gibi in any channel to start._'
+            }
+          });
+        }
+
+        blocks.push({
+          type: 'context',
+          elements: [
+            {
+              type: 'mrkdwn',
+              text: `Last updated: ${new Date().toLocaleString()}`
+            }
+          ]
+        });
+
+        await client.views.publish({
+          user_id: event.user,
+          view: {
+            type: 'home',
+            blocks: blocks
+          }
+        });
+      } catch (error) {
+        logger.error('Error publishing Home tab:', error);
+      }
+    });
+
+    // Start your app
+    await app.start(process.env.PORT || 3000);
+    console.log('🐒 Gibi is running!');
+
+  } catch (error: any) {
+    await handleAuthError(error);
+  }
+};
+
+const handleAuthError = async (error: any) => {
+  if (isRestarting) return;
+
+  if (error?.data?.error === 'invalid_auth') {
+    isRestarting = true;
+    console.error('\n❌ Authentication failed: The stored Slack tokens seem to be invalid.');
+    console.error('   Clearing stored configuration and restarting setup...');
+
+    await clearConfig(['SLACK_BOT_TOKEN']);
+
+    console.log('\n🔄 Restarting app setup...\n');
+    isRestarting = false;
+    await start(); // Recursively restart
+  } else {
+    console.error('Failed to start app:', error);
+    process.exit(1);
+  }
+};
+
+// Start the application
+start();
+
+// Global error handlers to catch any unhandled promise rejections
+process.on('unhandledRejection', async (reason: any) => {
+  await handleAuthError(reason);
+});
+
+process.on('uncaughtException', async (error: any) => {
+  await handleAuthError(error);
+});