@link-assistant/hive-mind 0.42.2 → 0.43.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @link-assistant/hive-mind
 
+## 0.43.0
+
+### Minor Changes
+
+- fe002f8: Add --prompt-issue-reporting flag for automatic issue creation
+
+  This release introduces a new opt-in feature that enables the AI to automatically create GitHub issues when it spots bugs, errors, or minor issues during working sessions that are not related to the main task.
+
+  **New Features:**
+
+  - Added `--prompt-issue-reporting` CLI flag (disabled by default)
+  - Issues include reproducible examples, workarounds, and fix suggestions
+  - Supports creating issues in both current and third-party repositories
+  - Automatic duplicate checking before creating issues
+
+  **Usage:**
+
+  ```bash
+  hive solve <issue-url> --prompt-issue-reporting
+  solve <issue-url> --prompt-issue-reporting
+  ```
+
+  **Implementation:**
+
+  - New guideline in system prompt (conditional on flag)
+  - Flag added to both `hive` and `solve` commands
+  - Uses `gh` CLI for authenticated issue creation (works with private repos)
+
+  This feature helps ensure that no bugs slip through the cracks during development while giving users full control over when it's active.
+
+## 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

package/package.json

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

package/src/claude.prompts.lib.mjs

@@ -115,6 +115,7 @@ General guidelines.
    - When you execute commands, always save their logs to files for easier reading if the output becomes large.
    - When running commands, do not set a timeout yourself — let them run as long as needed (default timeout - 2 minutes is more than enough), and once they finish, review the logs in the file.
    - When running sudo commands (especially package installations like apt-get, yum, npm install, etc.), always run them in the background to avoid timeout issues and permission errors when the process needs to be killed. Use the run_in_background parameter or append & to the command.
+${argv && argv.promptIssueReporting ? `   - When you spot any errors or bugs or minor issues during working session that are not related to requirements of the main task, create issues to track them if they do not exist yet. The issue should contain reproducible examples (ideally minimum reproducible example), workarounds, and suggestions for fixing the issue in code. For issues in the current repository, use gh issue create --repo ${owner}/${repo} --title "Issue title" --body "Issue description". For issues in third-party repositories on GitHub (libraries/components used in the working repository), use gh issue create --repo owner/repo --title "Issue title" --body "Issue description". Always check first if similar issues already exist using gh issue list --repo owner/repo --search "keywords" to avoid duplicates. If a similar issue already exists, add a comment to that issue using gh issue comment <issue-number> --repo owner/repo --body "Comment text" describing your specific case, including logs (anonymized with redacted personal and sensitive data), ways to reproduce, ideally minimum reproducible example, workarounds, and suggestions for fix - similar to how you would describe the issue if it didn't exist yet.` : ''}
    - When CI is failing or user reports failures, consider adding a detailed investigation protocol to your todo list with these steps:
       Step 1: List recent runs with timestamps using: gh run list --repo ${owner}/${repo} --branch ${branchName} --limit 5 --json databaseId,conclusion,createdAt,headSha
       Step 2: Verify runs are after the latest commit by checking timestamps and SHA

package/src/hive.config.lib.mjs

@@ -251,6 +251,11 @@ export const createYargsConfig = (yargsInstance) => {
       description: 'Prompt AI to use general-purpose sub agents for processing large tasks with multiple files/folders. Only supported for --tool claude.',
       default: false
     })
+    .option('prompt-issue-reporting', {
+      type: 'boolean',
+      description: 'Enable automatic issue creation for spotted bugs/errors not related to main task. Issues will include reproducible examples, workarounds, and fix suggestions. Works for both current and third-party repositories. Only supported for --tool claude.',
+      default: false
+    })
     .parserConfiguration({
       'boolean-negation': true,
       'strip-dashed': false,

package/src/hive.mjs

@@ -757,6 +757,7 @@ async function worker(workerId) {
         const prefixForkNameWithOwnerNameFlag = argv.prefixForkNameWithOwnerName ? ' --prefix-fork-name-with-owner-name' : '';
         const interactiveModeFlag = argv.interactiveMode ? ' --interactive-mode' : '';
         const promptExploreSubAgentFlag = argv.promptExploreSubAgent ? ' --prompt-explore-sub-agent' : '';
+        const promptIssueReportingFlag = argv.promptIssueReporting ? ' --prompt-issue-reporting' : '';
 
         // Use spawn to get real-time streaming output while avoiding command-stream's automatic quote addition
         const { spawn } = await import('child_process');
@@ -806,9 +807,10 @@ async function worker(workerId) {
         if (argv.prefixForkNameWithOwnerName) args.push('--prefix-fork-name-with-owner-name');
         if (argv.interactiveMode) args.push('--interactive-mode');
         if (argv.promptExploreSubAgent) args.push('--prompt-explore-sub-agent');
+        if (argv.promptIssueReporting) args.push('--prompt-issue-reporting');
 
         // Log the actual command being executed so users can investigate/reproduce
-        const command = `${solveCommand} "${issueUrl}" --model ${argv.model}${toolFlag}${forkFlag}${autoForkFlag}${verboseFlag}${attachLogsFlag}${targetBranchFlag}${logDirFlag}${dryRunFlag}${skipToolConnectionCheckFlag}${autoContinueFlag}${thinkFlag}${promptPlanSubAgentFlag}${noSentryFlag}${watchFlag}${prefixForkNameWithOwnerNameFlag}${interactiveModeFlag}${promptExploreSubAgentFlag}`;
+        const command = `${solveCommand} "${issueUrl}" --model ${argv.model}${toolFlag}${forkFlag}${autoForkFlag}${verboseFlag}${attachLogsFlag}${targetBranchFlag}${logDirFlag}${dryRunFlag}${skipToolConnectionCheckFlag}${autoContinueFlag}${thinkFlag}${promptPlanSubAgentFlag}${noSentryFlag}${watchFlag}${prefixForkNameWithOwnerNameFlag}${interactiveModeFlag}${promptExploreSubAgentFlag}${promptIssueReportingFlag}`;
         await log(`   📋 Command: ${command}`);
 
         let exitCode = 0;
@@ -1496,4 +1498,4 @@ try {
   process.exit(1);
 }
 
-} // End of main execution block
+} // End of main execution block

package/src/solve.config.lib.mjs

@@ -255,6 +255,11 @@ export const createYargsConfig = (yargsInstance) => {
       description: 'Prompt AI to use general-purpose sub agents for processing large tasks with multiple files/folders. Only supported for --tool claude.',
       default: false
     })
+    .option('prompt-issue-reporting', {
+      type: 'boolean',
+      description: 'Enable automatic issue creation for spotted bugs/errors not related to main task. Issues will include reproducible examples, workarounds, and fix suggestions. Works for both current and third-party repositories. Only supported for --tool claude.',
+      default: false
+    })
     .parserConfiguration({
       'boolean-negation': true
     })

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;
+}