@link-assistant/hive-mind 0.42.3 → 0.44.0

package/CHANGELOG.md

@@ -1,5 +1,67 @@
 # @link-assistant/hive-mind
 
+## 0.44.0
+
+### Minor Changes
+
+- b72136f: Add /version command to hive-telegram-bot
+
+  Implements a new /version command that displays comprehensive version information including:
+
+  - Bot version (package version with git commit SHA in development)
+  - solve and hive command versions
+  - Node.js runtime version
+  - Platform information (OS and architecture)
+
+  This helps users and administrators quickly check version information without accessing logs or the server directly.
+
+### Patch Changes
+
+- 445091b: Fix Perl version detection in ubuntu-24-server-install.sh
+
+  The `perlbrew available` command output was not being parsed correctly, causing the installation script to skip Perl installation with the message "Could not determine latest Perl version."
+
+  **Changes:**
+
+  - Use `grep -oE` to robustly extract Perl version strings regardless of line formatting
+  - Capture stderr from `perlbrew available` for better debugging
+  - Add debug output showing `perlbrew available` response when version detection fails
+  - Works with 'i' markers for already-installed versions and variable indentation
+
+  This ensures the latest Perl version is properly detected and installed via perlbrew.
+
+  Fixes #948
+
+## 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "0.42.3",
+  "version": "0.44.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

@@ -47,6 +47,9 @@ const { validateModelName } = await import('./model-validation.lib.mjs');
 // Import Claude limits library for /limits command
 const { getClaudeUsageLimits, formatUsageMessage } = await import('./claude-limits.lib.mjs');
 
+// Import version info library for /version command
+const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
+
 // Import Telegram markdown escaping utilities
 const { escapeMarkdown, escapeMarkdownV2 } = await import('./telegram-markdown.lib.mjs');
 
@@ -762,11 +765,9 @@ bot.command('help', async (ctx) => {
   }
 
   message += '*/limits* - Show Claude usage limits\n';
-  message += 'Usage: `/limits`\n';
-  message += 'Shows current session and weekly usage percentages\n\n';
-
+  message += '*/version* - Show bot and runtime versions\n';
   message += '*/help* - Show this help message\n\n';
-  message += '⚠️ *Note:* /solve, /hive and /limits commands only work in group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /hive, /limits and /version commands only work in group chats.\n\n';
   message += '🔧 *Available Options:*\n';
   message += '• `--fork` - Fork the repository\n';
   message += '• `--auto-fork` - Automatically fork public repos without write access\n';
@@ -875,7 +876,18 @@ bot.command('limits', async (ctx) => {
     { parse_mode: 'Markdown' }
   );
 });
-
+bot.command('version', async (ctx) => {
+  VERBOSE && console.log('[VERBOSE] /version command received');
+  await addBreadcrumb({ category: 'telegram.command', message: '/version command received', level: 'info', data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username } });
+  if (isOldMessage(ctx) || isForwardedOrReply(ctx)) return;
+  if (!isGroupChat(ctx)) return await ctx.reply('❌ The /version 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 });
+  const fetchingMessage = await ctx.reply('🔄 Gathering version information...', { reply_to_message_id: ctx.message.message_id });
+  const result = await getVersionInfo(VERBOSE);
+  if (!result.success) return await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ ${escapeMarkdownV2(result.error, { preserveCodeBlocks: true })}`, { parse_mode: 'MarkdownV2' });
+  await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, '🤖 *Version Information*\n\n' + formatVersionMessage(result.versions), { parse_mode: 'Markdown' });
+});
 bot.command(/^solve$/i, async (ctx) => {
   if (VERBOSE) {
     console.log('[VERBOSE] /solve command received');
@@ -1264,14 +1276,12 @@ if (VERBOSE) {
 bot.catch((error, ctx) => {
   console.error('Unhandled error while processing update', ctx.update.update_id);
   console.error('Error:', error);
-
   // Log detailed error information
   console.error('Error details:', {
     name: error.name,
     message: error.message,
     stack: error.stack?.split('\n').slice(0, 10).join('\n'),
   });
-
   // Log context information for debugging
   if (VERBOSE) {
     console.log('[VERBOSE] Error context:', {

package/src/version-info.lib.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+
+// Version information library for hive-mind project
+// Provides comprehensive version information for bot, commands, and runtime
+
+import { getVersion } from './version.lib.mjs';
+import { execSync } from 'child_process';
+
+/**
+ * Execute a command and return its output, or null if it fails
+ * @param {string} command - Command to execute
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {string|null} Command output or null
+ */
+function execCommand(command, verbose = false) {
+  try {
+    const result = execSync(command, { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'ignore'] });
+    const trimmed = result.trim();
+    // Return null if the output looks like an error message
+    if (trimmed.includes('not found') || trimmed.includes('command not found') || trimmed === '') {
+      return null;
+    }
+    return trimmed;
+  } catch (error) {
+    if (verbose) {
+      console.log(`[VERBOSE] Command failed: ${command}`, error.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Get comprehensive version information for all components
+ * @param {boolean} verbose - Enable verbose logging
+ * @returns {Promise<Object>} Version information object
+ */
+export async function getVersionInfo(verbose = false) {
+  try {
+    if (verbose) {
+      console.log('[VERBOSE] Gathering version information...');
+    }
+
+    // Get hive-mind package version
+    const packageVersion = await getVersion();
+    if (verbose) {
+      console.log(`[VERBOSE] Package version: ${packageVersion}`);
+    }
+
+    // === Agents ===
+
+    // Claude Code
+    const claudeVersion = execCommand('claude --version 2>&1', verbose);
+    if (verbose && claudeVersion) {
+      console.log(`[VERBOSE] Claude Code version: ${claudeVersion}`);
+    }
+
+    // Playwright
+    const playwrightVersion = execCommand('playwright --version 2>&1', verbose);
+    if (verbose && playwrightVersion) {
+      console.log(`[VERBOSE] Playwright version: ${playwrightVersion}`);
+    }
+
+    // Playwright MCP (check if installed via npm)
+    const playwrightMcpVersion = execCommand('npm list -g @playwright/mcp --depth=0 2>&1 | grep @playwright/mcp | awk \'{print $2}\'', verbose);
+    if (verbose && playwrightMcpVersion) {
+      console.log(`[VERBOSE] Playwright MCP version: ${playwrightMcpVersion}`);
+    }
+
+    // === Language Runtimes ===
+
+    // Node.js (from process, always available)
+    const nodeVersion = process.version;
+    if (verbose) {
+      console.log(`[VERBOSE] Node.js version: ${nodeVersion}`);
+    }
+
+    // Python
+    const pythonVersion = execCommand('python --version 2>&1', verbose);
+    if (verbose && pythonVersion) {
+      console.log(`[VERBOSE] Python version: ${pythonVersion}`);
+    }
+
+    // Pyenv
+    const pyenvVersion = execCommand('pyenv --version 2>&1', verbose);
+    if (verbose && pyenvVersion) {
+      console.log(`[VERBOSE] Pyenv version: ${pyenvVersion}`);
+    }
+
+    // Rust
+    const rustVersion = execCommand('rustc --version 2>&1', verbose);
+    if (verbose && rustVersion) {
+      console.log(`[VERBOSE] Rust version: ${rustVersion}`);
+    }
+
+    // Cargo
+    const cargoVersion = execCommand('cargo --version 2>&1', verbose);
+    if (verbose && cargoVersion) {
+      console.log(`[VERBOSE] Cargo version: ${cargoVersion}`);
+    }
+
+    // PHP
+    const phpVersion = execCommand('php --version 2>&1 | head -n1', verbose);
+    if (verbose && phpVersion) {
+      console.log(`[VERBOSE] PHP version: ${phpVersion}`);
+    }
+
+    // Bun
+    const bunVersion = execCommand('bun --version 2>&1', verbose);
+    if (verbose && bunVersion) {
+      console.log(`[VERBOSE] Bun version: ${bunVersion}`);
+    }
+
+    // .NET
+    const dotnetVersion = execCommand('dotnet --version 2>&1', verbose);
+    if (verbose && dotnetVersion) {
+      console.log(`[VERBOSE] .NET version: ${dotnetVersion}`);
+    }
+
+    // === Development Tools ===
+
+    // Git
+    const gitVersion = execCommand('git --version 2>&1', verbose);
+    if (verbose && gitVersion) {
+      console.log(`[VERBOSE] Git version: ${gitVersion}`);
+    }
+
+    // GitHub CLI
+    const ghVersion = execCommand('gh --version 2>&1 | head -n1', verbose);
+    if (verbose && ghVersion) {
+      console.log(`[VERBOSE] GitHub CLI version: ${ghVersion}`);
+    }
+
+    // NVM
+    const nvmVersion = execCommand('nvm --version 2>&1', verbose);
+    if (verbose && nvmVersion) {
+      console.log(`[VERBOSE] NVM version: ${nvmVersion}`);
+    }
+
+    // Homebrew
+    const brewVersion = execCommand('brew --version 2>&1 | head -n1', verbose);
+    if (verbose && brewVersion) {
+      console.log(`[VERBOSE] Homebrew version: ${brewVersion}`);
+    }
+
+    // NPM
+    const npmVersion = execCommand('npm --version 2>&1', verbose);
+    if (verbose && npmVersion) {
+      console.log(`[VERBOSE] NPM version: ${npmVersion}`);
+    }
+
+    // === Platform Information ===
+    const platform = process.platform;
+    const arch = process.arch;
+    if (verbose) {
+      console.log(`[VERBOSE] Platform: ${platform} (${arch})`);
+    }
+
+    // Build version info object
+    const versionInfo = {
+      success: true,
+      versions: {
+        // Bot components
+        bot: packageVersion,
+        solve: packageVersion,
+        hive: packageVersion,
+
+        // Agents
+        claudeCode: claudeVersion,
+        playwright: playwrightVersion,
+        playwrightMcp: playwrightMcpVersion,
+
+        // Language runtimes
+        node: nodeVersion,
+        python: pythonVersion,
+        rust: rustVersion,
+        php: phpVersion,
+        bun: bunVersion,
+        dotnet: dotnetVersion,
+
+        // Development tools
+        git: gitVersion,
+        gh: ghVersion,
+        npm: npmVersion,
+        nvm: nvmVersion,
+        pyenv: pyenvVersion,
+        cargo: cargoVersion,
+        brew: brewVersion,
+
+        // Platform
+        platform: `${platform} (${arch})`,
+      },
+    };
+
+    if (verbose) {
+      console.log('[VERBOSE] Version info gathered successfully:', JSON.stringify(versionInfo, null, 2));
+    }
+
+    return versionInfo;
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] Error gathering version info:', error);
+    }
+
+    return {
+      success: false,
+      error: error.message || 'Failed to gather version information',
+    };
+  }
+}
+
+/**
+ * Format version information as a Telegram message
+ * @param {Object} versions - Version information object
+ * @returns {string} Formatted message
+ */
+export function formatVersionMessage(versions) {
+  const lines = [];
+
+  // === Bot Components ===
+  lines.push('*🤖 Bot Components*');
+  if (versions.bot) {
+    lines.push(`• Bot: \`${versions.bot}\``);
+  }
+  if (versions.solve) {
+    lines.push(`• solve: \`${versions.solve}\``);
+  }
+  if (versions.hive) {
+    lines.push(`• hive: \`${versions.hive}\``);
+  }
+
+  // === Agents ===
+  const agentLines = [];
+  if (versions.claudeCode) {
+    agentLines.push(`• Claude Code: \`${versions.claudeCode}\``);
+  }
+  if (versions.playwright) {
+    agentLines.push(`• Playwright: \`${versions.playwright}\``);
+  }
+  if (versions.playwrightMcp) {
+    agentLines.push(`• Playwright MCP: \`${versions.playwrightMcp}\``);
+  }
+
+  if (agentLines.length > 0) {
+    lines.push('');
+    lines.push('*🎭 Agents*');
+    lines.push(...agentLines);
+  }
+
+  // === Language Runtimes ===
+  const runtimeLines = [];
+  if (versions.node) {
+    runtimeLines.push(`• Node.js: \`${versions.node}\``);
+  }
+  if (versions.python) {
+    runtimeLines.push(`• Python: \`${versions.python}\``);
+  }
+  if (versions.rust) {
+    runtimeLines.push(`• Rust: \`${versions.rust}\``);
+  }
+  if (versions.php) {
+    runtimeLines.push(`• PHP: \`${versions.php}\``);
+  }
+  if (versions.bun) {
+    runtimeLines.push(`• Bun: \`${versions.bun}\``);
+  }
+  if (versions.dotnet) {
+    runtimeLines.push(`• .NET: \`${versions.dotnet}\``);
+  }
+
+  if (runtimeLines.length > 0) {
+    lines.push('');
+    lines.push('*⚙️ Language Runtimes*');
+    lines.push(...runtimeLines);
+  }
+
+  // === Development Tools ===
+  const toolLines = [];
+  if (versions.git) {
+    toolLines.push(`• Git: \`${versions.git}\``);
+  }
+  if (versions.gh) {
+    toolLines.push(`• GitHub CLI: \`${versions.gh}\``);
+  }
+  if (versions.npm) {
+    toolLines.push(`• NPM: \`${versions.npm}\``);
+  }
+  if (versions.nvm) {
+    toolLines.push(`• NVM: \`${versions.nvm}\``);
+  }
+  if (versions.pyenv) {
+    toolLines.push(`• Pyenv: \`${versions.pyenv}\``);
+  }
+  if (versions.cargo) {
+    toolLines.push(`• Cargo: \`${versions.cargo}\``);
+  }
+  if (versions.brew) {
+    toolLines.push(`• Homebrew: \`${versions.brew}\``);
+  }
+
+  if (toolLines.length > 0) {
+    lines.push('');
+    lines.push('*🛠 Development Tools*');
+    lines.push(...toolLines);
+  }
+
+  // === Platform ===
+  if (versions.platform) {
+    lines.push('');
+    lines.push('*💻 Platform*');
+    lines.push(`• System: \`${versions.platform}\``);
+  }
+
+  return lines.join('\n');
+}
+
+export default {
+  getVersionInfo,
+  formatVersionMessage,
+};