@link-assistant/hive-mind 0.51.4 → 0.51.6

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @link-assistant/hive-mind
 
+## 0.51.6
+
+### Patch Changes
+
+- 9ee79c8: fix(ci): Add timeout, verbose diagnostics, and pre-fetch caching for Docker ARM64 builds
+
+  Addresses issue #998 where Docker Publish (linux/arm64) was stuck for >1.5 hours due to slow Homebrew bottle downloads on GitHub's ARM64 runners.
+
+  Changes:
+  - Added 90-minute timeout to docker-publish jobs to prevent indefinite hangs
+  - Switched from ubuntu-24.04-arm to ubuntu-22.04-arm for better network performance
+  - Added documentation comments about known ARM64 runner issues
+  - Added Homebrew verbose mode (`HOMEBREW_VERBOSE=1`) for detailed diagnostics
+  - Added `brew fetch --deps --retry` to pre-download bottles before installation
+  - Added timing measurements for fetch and install steps
+  - Updated case study with diagnostic approach
+
+  Root cause: GitHub's ubuntu-24.04-arm runners have known network performance issues (actions/runner-images#11790, actions/partner-runner-images#101). The ARM64 build was stuck downloading Homebrew bottles for PHP dependencies at extremely slow speeds.
+
+  See docs/case-studies/issue-998/README.md for detailed analysis.
+
+## 0.51.5
+
+### Patch Changes
+
+- 1a17f74: feat: add disk space information to /limits command
+
+  Adds free disk space percentage and size information to the Telegram bot's /limits command output, allowing users to monitor disk usage alongside Claude API limits and plan issue execution accordingly.
+
 ## 0.51.4
 
 ### Patch Changes

package/package.json

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

package/src/claude-limits.lib.mjs

@@ -4,9 +4,13 @@
  * Provides functions to fetch and parse Claude usage limits via OAuth API
  */
 
+import { exec } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
 
 /**
  * Default path to Claude credentials file
@@ -127,6 +131,101 @@ function formatCurrentTime() {
   return `${month} ${day}, ${hour12}:${minutes.toString().padStart(2, '0')}${ampm} UTC`;
 }
 
+/**
+ * Format bytes into human-readable size
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Formatted size (e.g., "19.3 GB")
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  // Use 1 decimal place for GB and above, none for smaller units
+  const decimals = i >= 3 ? 1 : 0;
+  return `${value.toFixed(decimals)} ${sizes[i]}`;
+}
+
+/**
+ * Get disk space information for the current filesystem
+ * Returns total, used, available space and usage percentage
+ *
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Object} Object with success boolean, and either disk space data or error message
+ */
+export async function getDiskSpaceInfo(verbose = false) {
+  try {
+    let totalMB, usedMB, availableMB, usedPercentage;
+
+    if (process.platform === 'darwin') {
+      // macOS: use df with 1024-byte blocks and parse
+      const { stdout } = await execAsync("df -k . 2>/dev/null | tail -1 | awk '{print $2, $3, $4}'");
+      const [totalKB, usedKB, availableKB] = stdout.trim().split(/\s+/).map(Number);
+      totalMB = Math.round(totalKB / 1024);
+      usedMB = Math.round(usedKB / 1024);
+      availableMB = Math.round(availableKB / 1024);
+    } else if (process.platform === 'win32') {
+      // Windows: use PowerShell to get drive info
+      const { stdout } = await execAsync('powershell -Command "$drive = (Get-Location).Drive; $info = Get-PSDrive -Name $drive.Name; Write-Output \\"$($info.Used) $($info.Free)\\""');
+      const [usedBytes, freeBytes] = stdout.trim().split(/\s+/).map(Number);
+      const totalBytes = usedBytes + freeBytes;
+      totalMB = Math.round(totalBytes / (1024 * 1024));
+      usedMB = Math.round(usedBytes / (1024 * 1024));
+      availableMB = Math.round(freeBytes / (1024 * 1024));
+    } else {
+      // Linux: use df with megabyte blocks
+      const { stdout } = await execAsync("df -BM . 2>/dev/null | tail -1 | awk '{print $2, $3, $4}'");
+      const parts = stdout
+        .trim()
+        .split(/\s+/)
+        .map(s => parseInt(s.replace('M', '')));
+      [totalMB, usedMB, availableMB] = parts;
+    }
+
+    if (isNaN(totalMB) || isNaN(usedMB) || isNaN(availableMB)) {
+      return {
+        success: false,
+        error: 'Failed to parse disk space information',
+      };
+    }
+
+    // Calculate used percentage (rounded to nearest integer)
+    usedPercentage = Math.round((usedMB / totalMB) * 100);
+    // Free percentage is the inverse
+    const freePercentage = 100 - usedPercentage;
+
+    if (verbose) {
+      console.log(`[VERBOSE] /limits disk space: ${availableMB}MB free of ${totalMB}MB total (${freePercentage}% free)`);
+    }
+
+    return {
+      success: true,
+      diskSpace: {
+        totalMB,
+        usedMB,
+        availableMB,
+        totalBytes: totalMB * 1024 * 1024,
+        usedBytes: usedMB * 1024 * 1024,
+        availableBytes: availableMB * 1024 * 1024,
+        usedPercentage,
+        freePercentage,
+        totalFormatted: formatBytes(totalMB * 1024 * 1024),
+        usedFormatted: formatBytes(usedMB * 1024 * 1024),
+        availableFormatted: formatBytes(availableMB * 1024 * 1024),
+      },
+    };
+  } catch (error) {
+    if (verbose) {
+      console.error('[VERBOSE] /limits disk space error:', error);
+    }
+    return {
+      success: false,
+      error: `Failed to get disk space info: ${error.message}`,
+    };
+  }
+}
+
 /**
  * Get Claude usage limits by calling the Anthropic OAuth usage API
  * This approach is more reliable than trying to parse CLI output
@@ -285,15 +384,25 @@ export function calculateTimePassedPercentage(resetsAt, periodHours) {
 /**
  * Format Claude usage data into a Telegram-friendly message
  * @param {Object} usage - The usage object from getClaudeUsageLimits
+ * @param {Object} diskSpace - Optional disk space info from getDiskSpaceInfo
  * @returns {string} Formatted message
  */
-export function formatUsageMessage(usage) {
+export function formatUsageMessage(usage, diskSpace = null) {
   // Use code block for monospace font to align progress bars properly
   let message = '```\n';
 
   // Show current time
   message += `Current time: ${formatCurrentTime()}\n\n`;
 
+  // Disk space section (if provided)
+  if (diskSpace) {
+    message += 'Disk space\n';
+    // Show free percentage with progress bar (inverted - showing free space)
+    const freeBar = getProgressBar(diskSpace.freePercentage);
+    message += `${freeBar} ${diskSpace.freePercentage}% free\n`;
+    message += `${diskSpace.availableFormatted} free of ${diskSpace.totalFormatted}\n\n`;
+  }
+
   // Current session (five_hour)
   message += 'Current session\n';
   if (usage.currentSession.percentage !== null) {
@@ -383,6 +492,7 @@ export function formatUsageMessage(usage) {
 
 export default {
   getClaudeUsageLimits,
+  getDiskSpaceInfo,
   getProgressBar,
   calculateTimePassedPercentage,
   formatUsageMessage,

package/src/telegram-bot.mjs

@@ -45,7 +45,7 @@ const { parseGitHubUrl } = await import('./github.lib.mjs');
 const { validateModelName } = await import('./model-validation.lib.mjs');
 
 // Import Claude limits library for /limits command
-const { getClaudeUsageLimits, formatUsageMessage } = await import('./claude-limits.lib.mjs');
+const { getClaudeUsageLimits, getDiskSpaceInfo, formatUsageMessage } = await import('./claude-limits.lib.mjs');
 
 // Import version info library for /version command
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
@@ -844,12 +844,12 @@ bot.command('limits', async ctx => {
   }
 
   // Send "fetching" message to indicate work is in progress
-  const fetchingMessage = await ctx.reply('🔄 Fetching Claude usage limits...', {
+  const fetchingMessage = await ctx.reply('🔄 Fetching usage limits...', {
     reply_to_message_id: ctx.message.message_id,
   });
 
-  // Get the usage limits using the library function
-  const result = await getClaudeUsageLimits(VERBOSE);
+  // Get the usage limits and disk space info in parallel
+  const [result, diskSpaceResult] = await Promise.all([getClaudeUsageLimits(VERBOSE), getDiskSpaceInfo(VERBOSE)]);
 
   if (!result.success) {
     // Edit the fetching message to show the error
@@ -860,7 +860,9 @@ bot.command('limits', async ctx => {
   }
 
   // Format and edit the fetching message with the results
-  const message = '📊 *Claude Usage Limits*\n\n' + formatUsageMessage(result.usage);
+  // Pass disk space info if available (non-critical if it fails)
+  const diskSpace = diskSpaceResult.success ? diskSpaceResult.diskSpace : null;
+  const message = '📊 *Usage Limits*\n\n' + formatUsageMessage(result.usage, diskSpace);
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, {
     parse_mode: 'Markdown',
   });