@link-assistant/hive-mind 0.42.1 → 0.42.3

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @link-assistant/hive-mind
 
+## 0.42.3
+
+### Patch Changes
+
+- 64d6cf8: Add experimental /top command to Telegram bot
+
+  - Added /top command to show live system monitor in Telegram
+  - Displays auto-updating `top` output in a single message (updates every 2 seconds)
+  - Owner-only access with chat authorization checks
+  - Session isolation per chat using GNU screen
+  - Clean stop button to terminate monitoring session
+  - Marked as EXPERIMENTAL feature with user warnings
+  - Not documented in /help as requested
+  - Requires GNU screen to be installed on the system
+
+  Fixes #500
+
+## 0.42.2
+
+### Patch Changes
+
+- dca5bed: Make --auto-continue enabled by default
+
+  - Changed default value from false to true for --auto-continue in both hive and solve commands
+  - Smart handling of -s (--skip-issues-with-prs) flag interaction:
+    - When -s is used, auto-continue is automatically disabled to avoid conflicts
+    - Explicit --auto-continue with -s shows proper error message
+    - Users can still use --no-auto-continue to explicitly disable
+  - This improves user experience as users typically want to continue working on existing PRs
+
+  Fixes #454
+
 ## 0.42.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "0.42.1",
+  "version": "0.42.3",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/hive.mjs

@@ -22,11 +22,9 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
     const yargs = yargsModule.default || yargsModule;
     const { hideBin } = await use('yargs@17.7.2/helpers');
     const rawArgs = hideBin(process.argv);
-
     // Reuse createYargsConfig from shared module to avoid duplication
     const { createYargsConfig } = await import('./hive.config.lib.mjs');
     const helpYargs = createYargsConfig(yargs(rawArgs)).version(false);
-
     // Show help and exit
     helpYargs.showHelp();
     process.exit(0);
@@ -48,7 +46,6 @@ export { createYargsConfig } from './hive.config.lib.mjs';
 import { fileURLToPath } from 'url';
 const isDirectExecution = process.argv[1] === fileURLToPath(import.meta.url) ||
                           (process.argv[1] && (process.argv[1].includes('/hive') || process.argv[1].endsWith('hive')));
-
 if (isDirectExecution) {
 console.log('🐝 Hive Mind - AI-powered issue solver');
 console.log('   Initializing...');
@@ -63,7 +60,6 @@ const withTimeout = (promise, timeoutMs, operation) => {
     )
   ]);
 };
-
 // Use use-m to dynamically import modules for cross-runtime compatibility
 if (typeof use === 'undefined') {
   try {
@@ -157,7 +153,6 @@ async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIss
         return graphqlResult.issues;
       }
     }
-
     // Strategy 2: Fallback to gh api --paginate approach (comprehensive but slower)
     await log('   📋 Using gh api --paginate approach for comprehensive coverage...', { verbose: true });
 
@@ -170,18 +165,15 @@ async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIss
     } else {
       repoListCmd = `gh api users/${owner}/repos --paginate --jq '.[] | {name: .name, owner: .owner.login, isArchived: .archived}'`;
     }
-
     await log('   📋 Fetching repository list (using --paginate for unlimited pagination)...', { verbose: true });
     await log(`   🔎 Command: ${repoListCmd}`, { verbose: true });
 
     // Add delay for rate limiting
     await new Promise(resolve => setTimeout(resolve, 2000));
-
     const { stdout: repoOutput } = await execAsync(repoListCmd, { encoding: 'utf8', env: process.env });
     // Parse the output line by line, as gh api with --jq outputs one JSON object per line
     const repoLines = repoOutput.trim().split('\n').filter(line => line.trim());
     const allRepositories = repoLines.map(line => JSON.parse(line));
-
     await log(`   📊 Found ${allRepositories.length} repositories`);
 
     // Filter repositories to only include those owned by the target user/org
@@ -190,30 +182,24 @@ async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIss
       return repoOwner === owner;
     });
     const unownedCount = allRepositories.length - ownedRepositories.length;
-
     if (unownedCount > 0) {
       await log(`   ⏭️  Skipping ${unownedCount} repository(ies) not owned by ${owner}`);
     }
-
     // Filter out archived repositories from owned repositories
     const repositories = ownedRepositories.filter(repo => !repo.isArchived);
     const archivedCount = ownedRepositories.length - repositories.length;
-
     if (archivedCount > 0) {
       await log(`   ⏭️  Skipping ${archivedCount} archived repository(ies)`);
     }
-
     await log(`   ✅ Processing ${repositories.length} non-archived repositories owned by ${owner}`);
 
     let collectedIssues = [];
     let processedRepos = 0;
-
     // Process repositories in batches to avoid overwhelming the API
     for (const repo of repositories) {
       try {
         const repoName = repo.name;
         const ownerName = repo.owner?.login || owner;
-
         await log(`   🔍 Fetching issues from ${ownerName}/${repoName}...`, { verbose: true });
 
         // Build the appropriate issue list command
@@ -223,7 +209,6 @@ async function fetchIssuesFromRepositories(owner, scope, monitorTag, fetchAllIss
         } else {
           issueCmd = `gh issue list --repo ${ownerName}/${repoName} --state open --label "${monitorTag}" --json url,title,number,createdAt`;
         }
-
         // Add delay between repository requests
         await new Promise(resolve => setTimeout(resolve, 1000));
 
@@ -488,13 +473,26 @@ if (argv.projectMode) {
 const tool = argv.tool || 'claude';
 await validateAndExitOnInvalidModel(argv.model, tool, safeExit);
 
-// Validate conflicting options
-if (argv.skipIssuesWithPrs && argv.autoContinue) {
-  await log('❌ Conflicting options: --skip-issues-with-prs and --auto-continue cannot be used together', { level: 'error' });
-  await log('   --skip-issues-with-prs: Skips issues that have any open PRs', { level: 'error' });
-  await log('   --auto-continue: Continues with existing PRs instead of creating new ones', { level: 'error' });
-  await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
-  await safeExit(1, 'Error occurred');
+// Handle -s (--skip-issues-with-prs) and --auto-continue interaction
+// Detect if user explicitly passed --auto-continue or --no-auto-continue
+const hasExplicitAutoContinue = rawArgs.includes('--auto-continue');
+const hasExplicitNoAutoContinue = rawArgs.includes('--no-auto-continue');
+
+if (argv.skipIssuesWithPrs) {
+  // If user explicitly passed --auto-continue with -s, that's a conflict
+  if (hasExplicitAutoContinue) {
+    await log('❌ Conflicting options: --skip-issues-with-prs and --auto-continue cannot be used together', { level: 'error' });
+    await log('   --skip-issues-with-prs: Skips issues that have any open PRs', { level: 'error' });
+    await log('   --auto-continue: Continues with existing PRs instead of creating new ones', { level: 'error' });
+    await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
+    await safeExit(1, 'Error occurred');
+  }
+
+  // If user didn't explicitly set auto-continue, disable it when -s is used
+  // This is because -s means "skip issues with PRs" which conflicts with auto-continue
+  if (!hasExplicitNoAutoContinue) {
+    argv.autoContinue = false;
+  }
 }
 
 // Helper function to check GitHub permissions - moved to github.lib.mjs
@@ -751,7 +749,7 @@ async function worker(workerId) {
         const dryRunFlag = argv.dryRun ? ' --dry-run' : '';
         const skipToolConnectionCheckFlag = (argv.skipToolConnectionCheck || argv.toolConnectionCheck === false) ? ' --skip-tool-connection-check' : '';
         const toolFlag = argv.tool ? ` --tool ${argv.tool}` : '';
-        const autoContinueFlag = argv.autoContinue ? ' --auto-continue' : '';
+        const autoContinueFlag = argv.autoContinue ? ' --auto-continue' : ' --no-auto-continue';
         const thinkFlag = argv.think ? ` --think ${argv.think}` : '';
         const promptPlanSubAgentFlag = argv.promptPlanSubAgent ? ' --prompt-plan-sub-agent' : '';
         const noSentryFlag = !argv.sentry ? ' --no-sentry' : '';
@@ -794,6 +792,8 @@ async function worker(workerId) {
         }
         if (argv.autoContinue) {
           args.push('--auto-continue');
+        } else {
+          args.push('--no-auto-continue');
         }
         if (argv.think) {
           args.push('--think', argv.think);

package/src/telegram-bot.mjs

@@ -1225,45 +1225,37 @@ bot.command(/^hive$/i, async (ctx) => {
   }
 });
 
+// Register /top command from separate module
+// This keeps telegram-bot.mjs under the 1500 line limit
+const { registerTopCommand } = await import('./telegram-top-command.lib.mjs');
+registerTopCommand(bot, {
+  VERBOSE,
+  isOldMessage,
+  isForwardedOrReply,
+  isGroupChat,
+  isChatAuthorized
+});
+
 // Add message listener for verbose debugging
-// This helps diagnose if bot is receiving messages at all
 if (VERBOSE) {
   bot.on('message', (ctx, next) => {
-    console.log('[VERBOSE] Message received:');
-    console.log('[VERBOSE]   Chat ID:', ctx.chat?.id);
-    console.log('[VERBOSE]   Chat type:', ctx.chat?.type);
-    console.log('[VERBOSE]   Is forum:', ctx.chat?.is_forum);
-    console.log('[VERBOSE]   Is topic message:', ctx.message?.is_topic_message);
-    console.log('[VERBOSE]   Message thread ID:', ctx.message?.message_thread_id);
-    console.log('[VERBOSE]   Message date:', ctx.message?.date);
-    console.log('[VERBOSE]   Message text:', ctx.message?.text?.substring(0, 100));
-    console.log('[VERBOSE]   From user:', ctx.from?.username || ctx.from?.id);
-    console.log('[VERBOSE]   Bot start time:', BOT_START_TIME);
-    console.log('[VERBOSE]   Is old message:', isOldMessage(ctx));
-
-    // Detailed forwarding/reply detection debug info
     const msg = ctx.message;
-    const isForwarded = isForwardedOrReply(ctx);
-    console.log('[VERBOSE]   Is forwarded/reply:', isForwarded);
+    console.log('[VERBOSE] Message:', {
+      chatId: ctx.chat?.id, chatType: ctx.chat?.type, isForum: ctx.chat?.is_forum,
+      isTopicMsg: msg?.is_topic_message, threadId: msg?.message_thread_id, date: msg?.date,
+      text: msg?.text?.substring(0, 100), user: ctx.from?.username || ctx.from?.id,
+      botStartTime: BOT_START_TIME, isOld: isOldMessage(ctx), isForwarded: isForwardedOrReply(ctx),
+      isAuthorized: isChatAuthorized(ctx.chat?.id)
+    });
     if (msg) {
-      // Log ALL message fields to diagnose what Telegram is actually sending
-      console.log('[VERBOSE]   Full message object keys:', Object.keys(msg));
-      console.log('[VERBOSE]     - forward_origin:', JSON.stringify(msg.forward_origin));
-      console.log('[VERBOSE]     - forward_origin type:', typeof msg.forward_origin);
-      console.log('[VERBOSE]     - forward_origin truthy?:', !!msg.forward_origin);
-      console.log('[VERBOSE]     - forward_origin.type:', msg.forward_origin?.type);
-      console.log('[VERBOSE]     - forward_from:', JSON.stringify(msg.forward_from));
-      console.log('[VERBOSE]     - forward_from_chat:', JSON.stringify(msg.forward_from_chat));
-      console.log('[VERBOSE]     - forward_date:', msg.forward_date);
-      console.log('[VERBOSE]     - reply_to_message:', JSON.stringify(msg.reply_to_message));
-      console.log('[VERBOSE]     - reply_to_message type:', typeof msg.reply_to_message);
-      console.log('[VERBOSE]     - reply_to_message truthy?:', !!msg.reply_to_message);
-      console.log('[VERBOSE]     - reply_to_message.message_id:', msg.reply_to_message?.message_id);
-      console.log('[VERBOSE]     - reply_to_message.forum_topic_created:', JSON.stringify(msg.reply_to_message?.forum_topic_created));
+      console.log('[VERBOSE] Msg fields:', Object.keys(msg));
+      console.log('[VERBOSE] Forward/reply:', {
+        forward_origin: msg.forward_origin, forward_from: msg.forward_from,
+        forward_from_chat: msg.forward_from_chat, forward_date: msg.forward_date,
+        reply_to_message: msg.reply_to_message, reply_id: msg.reply_to_message?.message_id,
+        forum_topic_created: msg.reply_to_message?.forum_topic_created
+      });
     }
-
-    console.log('[VERBOSE]   Is authorized:', isChatAuthorized(ctx.chat?.id));
-    // Continue to next handler
     return next();
   });
 }
@@ -1391,9 +1383,9 @@ bot.telegram.deleteWebhook({ drop_pending_updates: true })
       });
     }
     return bot.launch({
-      // Only receive message updates (commands, text messages)
-      // This ensures the bot receives all message types including commands
-      allowedUpdates: ['message'],
+      // Receive message updates (commands, text messages) and callback queries (button clicks)
+      // This ensures the bot receives all message types including commands and button interactions
+      allowedUpdates: ['message', 'callback_query'],
       // Drop any pending updates that were sent before the bot started
       // This ensures we only process new messages sent after this bot instance started
       dropPendingUpdates: true

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

@@ -0,0 +1,325 @@
+/**
+ * Telegram /top command implementation
+ *
+ * This module provides the /top command functionality for the Telegram bot,
+ * allowing chat owners to view live system monitor output in an auto-updating message.
+ *
+ * Features:
+ * - Live system monitoring using GNU screen and top command
+ * - Auto-updates every 2 seconds
+ * - Owner-only access control
+ * - Session management per chat
+ * - Clean cleanup on stop
+ *
+ * @experimental This feature is marked as experimental
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+// Store active top sessions: Map<chatId, { messageId, screenName, intervalId }>
+const activeTopSessions = new Map();
+
+/**
+ * Captures top output from the file for a given chat
+ * @param {number} chatId - The chat ID
+ * @returns {Promise<string|null>} The formatted top output or null on error
+ */
+async function captureTopOutput(chatId) {
+  try {
+    const outputFile = `/tmp/top-output-${chatId}.txt`;
+    const { readFile } = await import('fs/promises');
+    const output = await readFile(outputFile, 'utf-8');
+
+    // Format output for Telegram (limit to first 30 lines to fit in message)
+    const lines = output.split('\n').slice(0, 30);
+    return lines.join('\n');
+  } catch (error) {
+    console.error('[ERROR] Failed to capture top output:', error);
+    return null;
+  }
+}
+
+/**
+ * Registers the /top 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
+ */
+export function registerTopCommand(bot, options) {
+  const {
+    VERBOSE = false,
+    isOldMessage,
+    isForwardedOrReply,
+    isGroupChat,
+    isChatAuthorized
+  } = options;
+
+  // /top command - show system top output in an auto-updating message (EXPERIMENTAL)
+  // Only accessible by chat owner
+  // Not documented in /help as requested in issue #500
+  bot.command('top', async (ctx) => {
+    if (VERBOSE) {
+      console.log('[VERBOSE] /top command received');
+    }
+
+    // Ignore messages sent before bot started
+    if (isOldMessage(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: old message');
+      }
+      return;
+    }
+
+    // Ignore forwarded or reply messages
+    if (isForwardedOrReply(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: forwarded or reply');
+      }
+      return;
+    }
+
+    if (!isGroupChat(ctx)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: not a group chat');
+      }
+      await ctx.reply('❌ The /top command only works in group chats.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId)) {
+      if (VERBOSE) {
+        console.log('[VERBOSE] /top ignored: chat not authorized');
+      }
+      await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot.`, { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    // Check if user is chat owner
+    try {
+      const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (chatMember.status !== 'creator') {
+        if (VERBOSE) {
+          console.log('[VERBOSE] /top ignored: user is not chat owner');
+        }
+        await ctx.reply('❌ This command is only available to the chat owner.', { reply_to_message_id: ctx.message.message_id });
+        return;
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to check chat member status:', error);
+      await ctx.reply('❌ Failed to verify permissions.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    if (VERBOSE) {
+      console.log('[VERBOSE] /top passed all checks, starting...');
+    }
+
+    // Show experimental feature warning
+    await ctx.reply('🧪 *EXPERIMENTAL FEATURE*\n\nThis command is experimental and may have issues. Use with caution.', {
+      parse_mode: 'Markdown',
+      reply_to_message_id: ctx.message.message_id
+    });
+
+    // Check if there's already an active top session for this chat
+    if (activeTopSessions.has(chatId)) {
+      await ctx.reply('❌ A top session is already running for this chat. Stop it first using the button.', { reply_to_message_id: ctx.message.message_id });
+      return;
+    }
+
+    // Generate screen session name with chat ID
+    const screenName = `top-chat-${chatId}`;
+
+    // Check if screen session already exists
+    let sessionExists = false;
+    try {
+      const { stdout } = await exec('screen -ls');
+      sessionExists = stdout.includes(screenName);
+    } catch {
+      // screen -ls returns non-zero when no sessions exist
+      sessionExists = false;
+    }
+
+    // Create screen session if it doesn't exist
+    // We'll use a different approach: run top in batch mode with output redirected to a file
+    // that we continuously read instead of using screen hardcopy
+    const outputFile = `/tmp/top-output-${chatId}.txt`;
+
+    if (!sessionExists) {
+      try {
+        // Start top in a screen session with batch mode, outputting to a file
+        // -b: batch mode, -d 2: 2 second delay between updates, -n: number of iterations (unlimited)
+        await exec(`screen -dmS ${screenName} bash -c 'while true; do top -b -n 1 > ${outputFile}; sleep 2; done'`);
+        if (VERBOSE) {
+          console.log(`[VERBOSE] Created screen session: ${screenName}`);
+        }
+        // Give top a moment to start and produce first output
+        await new Promise(resolve => setTimeout(resolve, 1500));
+      } catch (error) {
+        console.error('[ERROR] Failed to create screen session:', error);
+        await ctx.reply('❌ Failed to start top command.', { reply_to_message_id: ctx.message.message_id });
+        return;
+      }
+    }
+
+    // Send initial message with loading indicator
+    const initialMessage = await ctx.reply('🧪 📊 Loading system monitor... (EXPERIMENTAL)', {
+      reply_to_message_id: ctx.message.message_id,
+      reply_markup: {
+        inline_keyboard: [[
+          { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+        ]]
+      }
+    });
+
+    // Capture and display first output
+    const firstOutput = await captureTopOutput(chatId);
+    if (firstOutput) {
+      try {
+        await ctx.telegram.editMessageText(
+          chatId,
+          initialMessage.message_id,
+          undefined,
+          `\`\`\`\n${firstOutput}\n\`\`\``,
+          {
+            parse_mode: 'Markdown',
+            reply_markup: {
+              inline_keyboard: [[
+                { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+              ]]
+            }
+          }
+        );
+      } catch (error) {
+        console.error('[ERROR] Failed to update message:', error);
+      }
+    }
+
+    // Set up periodic update (every 2 seconds)
+    const intervalId = setInterval(async () => {
+      const output = await captureTopOutput(chatId);
+      if (output) {
+        try {
+          await ctx.telegram.editMessageText(
+            chatId,
+            initialMessage.message_id,
+            undefined,
+            `\`\`\`\n${output}\n\`\`\``,
+            {
+              parse_mode: 'Markdown',
+              reply_markup: {
+                inline_keyboard: [[
+                  { text: '🛑 Stop', callback_data: `stop_top_${chatId}` }
+                ]]
+              }
+            }
+          );
+        } catch (error) {
+          // Ignore "message is not modified" errors
+          if (!error.message?.includes('message is not modified')) {
+            console.error('[ERROR] Failed to update message:', error);
+          }
+        }
+      }
+    }, 2000);
+
+    // Store session info
+    activeTopSessions.set(chatId, {
+      messageId: initialMessage.message_id,
+      screenName,
+      intervalId
+    });
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Top session started for chat ${chatId}`);
+    }
+  });
+
+  // Handle stop button callback
+  bot.action(/^stop_top_(.+)$/, async (ctx) => {
+    const chatId = parseInt(ctx.match[1]);
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Stop top callback received for chat ${chatId}`);
+    }
+
+    // Check if user is chat owner
+    try {
+      const chatMember = await ctx.telegram.getChatMember(chatId, ctx.from.id);
+      if (chatMember.status !== 'creator') {
+        await ctx.answerCbQuery('❌ Only the chat owner can stop the top session.');
+        return;
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to check chat member status:', error);
+      await ctx.answerCbQuery('❌ Failed to verify permissions.');
+      return;
+    }
+
+    const session = activeTopSessions.get(chatId);
+    if (!session) {
+      await ctx.answerCbQuery('❌ No active top session found.');
+      return;
+    }
+
+    // Stop the update interval
+    clearInterval(session.intervalId);
+
+    // Kill the screen session
+    try {
+      await exec(`screen -S ${session.screenName} -X quit`);
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Killed screen session: ${session.screenName}`);
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to kill screen session:', error);
+    }
+
+    // Clean up the output file
+    try {
+      const { unlink } = await import('fs/promises');
+      await unlink(`/tmp/top-output-${chatId}.txt`);
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Cleaned up output file for chat ${chatId}`);
+      }
+    } catch (error) {
+      // Ignore file cleanup errors
+      if (VERBOSE) {
+        console.log(`[VERBOSE] Could not clean up output file: ${error.message}`);
+      }
+    }
+
+    // Remove from active sessions
+    activeTopSessions.delete(chatId);
+
+    // Update the message to show it's stopped
+    try {
+      await ctx.editMessageText('🛑 Top session stopped.', {
+        parse_mode: 'Markdown'
+      });
+    } catch (error) {
+      console.error('[ERROR] Failed to edit message:', error);
+    }
+
+    await ctx.answerCbQuery('✅ Top session stopped successfully.');
+
+    if (VERBOSE) {
+      console.log(`[VERBOSE] Top session stopped for chat ${chatId}`);
+    }
+  });
+}
+
+/**
+ * Gets information about active top sessions
+ * @returns {Map} Map of active sessions
+ */
+export function getActiveTopSessions() {
+  return activeTopSessions;
+}