@link-assistant/hive-mind 0.43.0 → 0.45.0

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @link-assistant/hive-mind
 
+## 0.45.0
+
+### Minor Changes
+
+- 81f8da0: Add `--tokens-budget-stats` option for detailed token usage analysis. This experimental feature shows context window usage and output token usage in absolute values and ratios when using `--tool claude`. Disabled by default.
+
+## 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

package/package.json

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

package/src/claude.budget-stats.lib.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+// Token budget statistics display module
+// Extracted from claude.lib.mjs to maintain file line limits
+
+import { formatNumber } from './claude.lib.mjs';
+
+/**
+ * Display token budget statistics (context window usage and ratios)
+ * @param {Object} usage - Usage data for a model
+ * @param {Function} log - Logging function
+ */
+export const displayBudgetStats = async (usage, log) => {
+  const modelInfo = usage.modelInfo;
+  if (!modelInfo?.limit) {
+    await log('\n      ⚠️  Budget stats not available (no model limits found)');
+    return;
+  }
+
+  await log('\n      📊 Token Budget Statistics:');
+
+  // Context window usage
+  if (modelInfo.limit.context) {
+    const contextLimit = modelInfo.limit.context;
+    // Input tokens include regular input + cache creation + cache read
+    const totalInputUsed = usage.inputTokens + usage.cacheCreationTokens + usage.cacheReadTokens;
+    const contextUsageRatio = totalInputUsed / contextLimit;
+    const contextUsagePercent = (contextUsageRatio * 100).toFixed(2);
+
+    await log('        Context window:');
+    await log(`          Used: ${formatNumber(totalInputUsed)} tokens`);
+    await log(`          Limit: ${formatNumber(contextLimit)} tokens`);
+    await log(`          Ratio: ${contextUsageRatio.toFixed(4)} (${contextUsagePercent}%)`);
+  }
+
+  // Output tokens usage
+  if (modelInfo.limit.output) {
+    const outputLimit = modelInfo.limit.output;
+    const outputUsageRatio = usage.outputTokens / outputLimit;
+    const outputUsagePercent = (outputUsageRatio * 100).toFixed(2);
+
+    await log('        Output tokens:');
+    await log(`          Used: ${formatNumber(usage.outputTokens)} tokens`);
+    await log(`          Limit: ${formatNumber(outputLimit)} tokens`);
+    await log(`          Ratio: ${outputUsageRatio.toFixed(4)} (${outputUsagePercent}%)`);
+  }
+
+  // Total session tokens (input + cache_creation + output)
+  const totalSessionTokens = usage.inputTokens + usage.cacheCreationTokens + usage.outputTokens;
+  await log(`        Total session tokens: ${formatNumber(totalSessionTokens)}`);
+};

package/src/claude.lib.mjs

@@ -13,6 +13,7 @@ import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
+import { displayBudgetStats } from './claude.budget-stats.lib.mjs';
 /**
  * Format numbers with spaces as thousands separator (no commas)
  * Per issue #667: Use spaces for thousands, . for decimals
@@ -1279,6 +1280,10 @@ export const executeClaudeCommand = async (params) => {
               const usage = tokenUsage.modelUsage[modelId];
               await log(`\n   📊 ${usage.modelName || modelId}:`);
               await displayModelUsage(usage, log);
+              // Display budget stats if flag is enabled
+              if (argv.tokensBudgetStats && usage.modelInfo?.limit) {
+                await displayBudgetStats(usage, log);
+              }
             }
             // Show totals if multiple models were used
             if (modelIds.length > 1) {

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('tokens-budget-stats', {
+      type: 'boolean',
+      description: '[EXPERIMENTAL] Show detailed token budget statistics including context window usage and ratios. 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.',

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('tokens-budget-stats', {
+      type: 'boolean',
+      description: '[EXPERIMENTAL] Show detailed token budget statistics including context window usage and ratios. 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.',

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