@link-assistant/hive-mind 1.7.2 → 1.9.0

package/src/telegram-bot.mjs

@@ -762,12 +762,15 @@ bot.command('help', async ctx => {
   message += '*/limits* - Show usage limits\n';
   message += '*/version* - Show bot and runtime versions\n';
   message += '*/accept\\_invites* - Accept all pending GitHub invitations\n';
+  message += '*/merge* - Merge queue (experimental)\n';
+  message += 'Usage: `/merge <github-repo-url>`\n';
+  message += "Merges all PRs with 'ready' label sequentially.\n";
   message += '*/help* - Show this help message\n\n';
-  message += '⚠️ *Note:* /solve, /hive, /limits, /version and /accept\\_invites commands only work in group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /hive, /limits, /version, /accept\\_invites and /merge commands only work in group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += '• `--model <model>` or `-m` - Specify AI model (sonnet, opus, haiku, haiku-3-5, haiku-3)\n';
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
-  message += '• `--think <level>` - Thinking level (low/medium/high/max)\n';
+  message += '• `--think <level>` - Thinking level (off/low/medium/high/max) | `--thinking-budget <num>` - Token budget (0-63999)\n';
   message += '• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR\n';
   message += '\n💡 *Tip:* Many more options available. See full documentation for complete list.\n';
 
@@ -901,6 +904,17 @@ registerAcceptInvitesCommand(bot, {
   addBreadcrumb,
 });
 
+// Register /merge command from separate module (experimental, see issue #1143)
+const { registerMergeCommand } = await import('./telegram-merge-command.lib.mjs');
+registerMergeCommand(bot, {
+  VERBOSE,
+  isOldMessage,
+  isForwardedOrReply,
+  isGroupChat,
+  isChatAuthorized,
+  addBreadcrumb,
+});
+
 bot.command(/^solve$/i, async ctx => {
   if (VERBOSE) {
     console.log('[VERBOSE] /solve command received');
@@ -1460,14 +1474,12 @@ bot.telegram
     process.exit(1);
   });
 
-// Helper to stop solve queue gracefully on shutdown
-// See: https://github.com/link-assistant/hive-mind/issues/1083
+// Helper to stop solve queue gracefully on shutdown (see issue #1083)
 const stopSolveQueue = () => {
   try {
     getSolveQueue({ verbose: VERBOSE }).stop();
-    if (VERBOSE) console.log('[VERBOSE] Solve queue stopped');
-  } catch (err) {
-    if (VERBOSE) console.log('[VERBOSE] Could not stop solve queue:', err.message);
+  } catch {
+    /* ignore errors during shutdown */
   }
 };
 
@@ -1481,10 +1493,8 @@ process.once('SIGINT', () => {
 
 process.once('SIGTERM', () => {
   isShuttingDown = true;
-  console.log('\n🛑 Received SIGTERM, stopping bot...');
+  console.log('\n🛑 Received SIGTERM, stopping bot... (Check system logs: journalctl -u <service> or dmesg)');
   if (VERBOSE) console.log(`[VERBOSE] Signal: SIGTERM, PID: ${process.pid}, PPID: ${process.ppid}`);
-  console.log('ℹ️  SIGTERM is typically sent by: system shutdown, process manager, kill command, or container orchestration');
-  console.log('💡 Check system logs for details: journalctl -u <service> or dmesg');
   stopSolveQueue();
   bot.stop('SIGTERM');
 });

package/src/telegram-merge-command.lib.mjs

@@ -0,0 +1,366 @@
+/**
+ * Telegram /merge command implementation
+ *
+ * This module provides the /merge command functionality for the Telegram bot,
+ * allowing users to process a repository's merge queue - merging all PRs
+ * with the 'ready' label sequentially.
+ *
+ * Features:
+ * - Accepts repository URL
+ * - Checks and creates 'ready' label if needed
+ * - Fetches all PRs/issues with 'ready' label
+ * - Merges PRs sequentially (oldest first)
+ * - Monitors CI/CD between merges (every 5 minutes)
+ * - Provides progress updates via single updated Telegram message
+ * - Cancel via inline button
+ * - Per-repository concurrency control (not per-chat)
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/1143
+ */
+
+import { parseRepositoryUrl, checkLabelPermissions, ensureReadyLabel } from './github-merge.lib.mjs';
+import { createMergeQueueProcessor, MergeStatus, MERGE_QUEUE_CONFIG } from './telegram-merge-queue.lib.mjs';
+
+/**
+ * Active merge operations map (repoKey -> { processor, chatId, messageId })
+ * Uses repository key (owner/repo) for per-repository concurrency control
+ */
+const activeMergeOperations = new Map();
+
+/**
+ * Generate repository key for the operations map
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @returns {string} Repository key
+ */
+function getRepoKey(owner, repo) {
+  return `${owner}/${repo}`.toLowerCase();
+}
+
+/**
+ * Escapes special characters in text for Telegram MarkdownV2 formatting
+ * @param {string} text - The text to escape
+ * @returns {string} The escaped text
+ */
+function escapeMarkdownV2(text) {
+  return String(text).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
+}
+
+/**
+ * Parse command arguments for /merge
+ * @param {string} text - Message text
+ * @returns {string[]} Array of arguments
+ */
+function parseCommandArgs(text) {
+  const firstLine = text.split('\n')[0].trim();
+  const argsText = firstLine.replace(/^\/\w+\s*/, '');
+
+  if (!argsText.trim()) {
+    return [];
+  }
+
+  const args = [];
+  let currentArg = '';
+  let inQuotes = false;
+  let quoteChar = null;
+
+  for (let i = 0; i < argsText.length; i++) {
+    const char = argsText[i];
+
+    if ((char === '"' || char === "'") && !inQuotes) {
+      inQuotes = true;
+      quoteChar = char;
+    } else if (char === quoteChar && inQuotes) {
+      inQuotes = false;
+      quoteChar = null;
+    } else if (char === ' ' && !inQuotes) {
+      if (currentArg) {
+        args.push(currentArg);
+        currentArg = '';
+      }
+    } else {
+      currentArg += char;
+    }
+  }
+
+  if (currentArg) {
+    args.push(currentArg);
+  }
+
+  return args;
+}
+
+/**
+ * Format user-friendly error message
+ * Hides debug info unless verbose mode is enabled
+ * @param {Error} error - The error object
+ * @param {boolean} verbose - Whether verbose logging is enabled
+ * @returns {string} User-friendly error message
+ */
+function formatUserError(error, verbose) {
+  // Map common errors to user-friendly messages
+  const errorMessage = error.message || String(error);
+
+  if (errorMessage.includes('rate limit')) {
+    return 'GitHub API rate limit exceeded. Please try again later.';
+  }
+  if (errorMessage.includes('permission') || errorMessage.includes('403')) {
+    return 'Insufficient permissions to access this repository. Please check access rights.';
+  }
+  if (errorMessage.includes('not found') || errorMessage.includes('404')) {
+    return 'Repository not found. Please check the URL and try again.';
+  }
+  if (errorMessage.includes('network') || errorMessage.includes('ECONNREFUSED')) {
+    return 'Network error. Please check your connection and try again.';
+  }
+
+  // For unknown errors, show generic message (detailed logs are in verbose mode)
+  if (verbose) {
+    return `Error: ${errorMessage}`;
+  }
+  return 'An error occurred. Please try again or contact support.';
+}
+
+/**
+ * Registers the /merge command handler with the bot
+ * @param {Object} bot - The Telegraf bot instance
+ * @param {Object} options - Options object
+ * @param {boolean} options.VERBOSE - Whether to enable verbose logging
+ * @param {Function} options.isOldMessage - Function to check if message is old
+ * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
+ * @param {Function} options.isGroupChat - Function to check if chat is a group
+ * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
+ */
+export function registerMergeCommand(bot, options) {
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb } = options;
+
+  bot.command(/^merge$/i, async ctx => {
+    VERBOSE && console.log('[VERBOSE] /merge command received');
+
+    await addBreadcrumb({
+      category: 'telegram.command',
+      message: '/merge command received',
+      level: 'info',
+      data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
+    });
+
+    // Standard checks
+    if (isOldMessage(ctx) || isForwardedOrReply(ctx)) return;
+
+    if (!isGroupChat(ctx)) {
+      return await ctx.reply('The /merge command only works in group chats. Please add this bot to a group and make it an admin.', {
+        reply_to_message_id: ctx.message.message_id,
+      });
+    }
+
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId)) {
+      return await ctx.reply(`This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
+        reply_to_message_id: ctx.message.message_id,
+      });
+    }
+
+    // Parse arguments
+    const args = parseCommandArgs(ctx.message.text);
+
+    if (args.length === 0) {
+      return await ctx.reply("Missing repository URL\\.\n\nUsage: `/merge <repository-url>`\n\nExample: `/merge https://github.com/owner/repo`\n\nThis will merge all PRs with the 'ready' label, one by one, waiting for CI/CD between each merge\\.", { parse_mode: 'MarkdownV2', reply_to_message_id: ctx.message.message_id });
+    }
+
+    // Parse and validate repository URL
+    const repoUrl = args[0];
+    const parsedUrl = parseRepositoryUrl(repoUrl);
+
+    if (!parsedUrl.valid) {
+      return await ctx.reply(`Invalid repository URL: ${escapeMarkdownV2(parsedUrl.error)}\n\nPlease provide a valid GitHub repository URL\\.`, {
+        parse_mode: 'MarkdownV2',
+        reply_to_message_id: ctx.message.message_id,
+      });
+    }
+
+    const { owner, repo } = parsedUrl;
+    const repoKey = getRepoKey(owner, repo);
+    VERBOSE && console.log(`[VERBOSE] /merge: Processing repository ${owner}/${repo}`);
+
+    // Check if a merge operation is already running for this repository (per-repository concurrency)
+    if (activeMergeOperations.has(repoKey)) {
+      const existingOp = activeMergeOperations.get(repoKey);
+      if (existingOp.processor.status === MergeStatus.RUNNING) {
+        return await ctx.reply(`A merge operation is already running for ${escapeMarkdownV2(owner)}/${escapeMarkdownV2(repo)}\\.\n\nPlease wait for it to complete or cancel it\\.`, {
+          parse_mode: 'MarkdownV2',
+          reply_to_message_id: ctx.message.message_id,
+        });
+      }
+    }
+
+    // Send initial status message (reply to the /merge command)
+    const statusMessage = await ctx.reply(`Initializing merge queue for ${escapeMarkdownV2(owner)}/${escapeMarkdownV2(repo)}\\.\\.\\.\n\nThis may take a moment\\.`, {
+      parse_mode: 'MarkdownV2',
+      reply_to_message_id: ctx.message.message_id,
+    });
+
+    try {
+      // Check permissions
+      const permCheck = await checkLabelPermissions(owner, repo, VERBOSE);
+      if (!permCheck.canManageLabels) {
+        await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `No permission to manage repository ${escapeMarkdownV2(owner)}/${escapeMarkdownV2(repo)}\\.\n\nPlease ensure you have write access to this repository\\.`, { parse_mode: 'MarkdownV2' });
+        return;
+      }
+
+      // Ensure ready label exists
+      const labelResult = await ensureReadyLabel(owner, repo, VERBOSE);
+      if (!labelResult.success) {
+        await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `Failed to setup 'ready' label: ${escapeMarkdownV2(labelResult.error)}`, {
+          parse_mode: 'MarkdownV2',
+        });
+        return;
+      }
+
+      const labelMsg = labelResult.created ? "\nCreated 'ready' label in repository\\." : '';
+
+      // Create the merge queue processor
+      const processor = await createMergeQueueProcessor(owner, repo, {
+        verbose: VERBOSE,
+        onProgress: async () => {
+          // Update message with progress and cancel button
+          try {
+            const message = processor.formatProgressMessage();
+            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, message, {
+              parse_mode: 'MarkdownV2',
+              reply_markup: {
+                inline_keyboard: [[{ text: '🛑 Cancel', callback_data: `merge_cancel_${repoKey}` }]],
+              },
+            });
+          } catch (err) {
+            // Ignore message edit errors (e.g., message not modified)
+            if (!err.message?.includes('message is not modified')) {
+              VERBOSE && console.log(`[VERBOSE] /merge: Error updating message: ${err.message}`);
+            }
+          }
+        },
+        onComplete: async () => {
+          try {
+            const message = processor.formatFinalMessage();
+            // Remove cancel button on completion
+            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, message, {
+              parse_mode: 'MarkdownV2',
+            });
+          } catch (err) {
+            VERBOSE && console.log(`[VERBOSE] /merge: Error sending final message: ${err.message}`);
+          }
+          activeMergeOperations.delete(repoKey);
+        },
+        onError: async error => {
+          VERBOSE && console.error(`[VERBOSE] /merge error for ${repoKey}:`, error);
+          try {
+            const userMessage = formatUserError(error, VERBOSE);
+            const finalReport = processor.formatFinalMessage();
+            await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `❌ *Merge queue failed*\n\n${escapeMarkdownV2(userMessage)}\n\n${finalReport}`, {
+              parse_mode: 'MarkdownV2',
+            });
+          } catch (err) {
+            VERBOSE && console.log(`[VERBOSE] /merge: Error sending error message: ${err.message}`);
+          }
+          activeMergeOperations.delete(repoKey);
+        },
+      });
+
+      // Initialize the processor
+      const initResult = await processor.initialize();
+
+      if (!initResult.success) {
+        const userMessage = formatUserError(new Error(initResult.error), VERBOSE);
+        await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `Failed to initialize merge queue: ${escapeMarkdownV2(userMessage)}`, {
+          parse_mode: 'MarkdownV2',
+        });
+        return;
+      }
+
+      if (initResult.message) {
+        // No PRs to merge
+        await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `*Merge Queue \\- ${escapeMarkdownV2(owner)}/${escapeMarkdownV2(repo)}*${labelMsg}\n\n${escapeMarkdownV2(initResult.message)}\n\nTo use the merge queue:\n1\\. Add the \`ready\` label to PRs you want to merge\n2\\. Run \`/merge ${escapeMarkdownV2(repoUrl)}\` again`, { parse_mode: 'MarkdownV2' });
+        return;
+      }
+
+      // Update message with PR list and cancel button, start processing
+      const truncatedMsg = initResult.truncated ? `\n\n_Note: Only processing first ${MERGE_QUEUE_CONFIG.MAX_PRS_PER_SESSION} PRs_` : '';
+
+      await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `*Merge Queue \\- ${escapeMarkdownV2(owner)}/${escapeMarkdownV2(repo)}*${labelMsg}\n\nFound ${initResult.count} PRs with 'ready' label\\.${escapeMarkdownV2(truncatedMsg)}\n\nStarting merge process\\.\\.\\.`, {
+        parse_mode: 'MarkdownV2',
+        reply_markup: {
+          inline_keyboard: [[{ text: '🛑 Cancel', callback_data: `merge_cancel_${repoKey}` }]],
+        },
+      });
+
+      // Store processor for this repository
+      activeMergeOperations.set(repoKey, {
+        processor,
+        chatId,
+        messageId: statusMessage.message_id,
+      });
+
+      // Run the merge queue (this runs asynchronously)
+      processor.run().catch(error => {
+        VERBOSE && console.error(`[VERBOSE] /merge: Unhandled error in run(): ${error.message}`);
+        activeMergeOperations.delete(repoKey);
+      });
+    } catch (error) {
+      VERBOSE && console.error('[VERBOSE] /merge error:', error);
+
+      try {
+        const userMessage = formatUserError(error, VERBOSE);
+        await ctx.telegram.editMessageText(statusMessage.chat.id, statusMessage.message_id, undefined, `Error processing merge queue: ${escapeMarkdownV2(userMessage)}\n\nPlease check the repository URL and try again\\.`, { parse_mode: 'MarkdownV2' });
+      } catch (editError) {
+        VERBOSE && console.error('[VERBOSE] /merge: Failed to edit error message:', editError);
+      }
+    }
+  });
+
+  // Handle cancel button callback
+  bot.action(/^merge_cancel_(.+)$/, async ctx => {
+    const repoKey = ctx.match[1];
+    VERBOSE && console.log(`[VERBOSE] /merge cancel callback received for ${repoKey}`);
+
+    const operation = activeMergeOperations.get(repoKey);
+    if (!operation || operation.processor.status !== MergeStatus.RUNNING) {
+      await ctx.answerCbQuery('No active merge operation found.');
+      return;
+    }
+
+    // Cancel the operation
+    operation.processor.cancel();
+    await ctx.answerCbQuery('Merge operation cancellation requested. The current PR will finish processing.');
+
+    VERBOSE && console.log(`[VERBOSE] /merge: Cancelled operation for ${repoKey}`);
+  });
+}
+
+/**
+ * Get active merge operation for a repository
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @returns {Object|null} Operation object or null
+ */
+export function getActiveMergeOperation(owner, repo) {
+  const repoKey = getRepoKey(owner, repo);
+  return activeMergeOperations.get(repoKey) || null;
+}
+
+/**
+ * Clear all active merge operations (useful for testing)
+ */
+export function clearAllMergeOperations() {
+  for (const [, operation] of activeMergeOperations) {
+    if (operation.processor.status === MergeStatus.RUNNING) {
+      operation.processor.cancel();
+    }
+  }
+  activeMergeOperations.clear();
+}
+
+export default {
+  registerMergeCommand,
+  getActiveMergeOperation,
+  clearAllMergeOperations,
+};