@link-assistant/hive-mind 1.9.0 → 1.9.2

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @link-assistant/hive-mind
 
+## 1.9.2
+
+### Patch Changes
+
+- d39bf3e: Fix disk threshold to use one-at-a-time mode instead of blocking all commands
+  - When disk usage exceeds threshold (90%), now allows exactly one command to run
+  - Previously, disk threshold blocked ALL commands unconditionally (like RAM/CPU)
+  - Now matches behavior of Claude API thresholds (CLAUDE_5_HOUR_SESSION_THRESHOLD, CLAUDE_WEEKLY_THRESHOLD)
+  - Allows controlled task execution during high disk usage while preventing multiple tasks from exhausting resources
+
+  Fixes #1155
+
+## 1.9.1
+
+### Patch Changes
+
+- 06da02c: Improve /accept_invites command output with grouped items and real-time updates
+
+  **Changes:**
+  - Group output by "Repositories:" and "Organizations:" instead of repeating "Repository:" for each item
+  - Add clickable GitHub links for each repository and organization
+  - Implement real-time message updates after each invitation is processed
+  - Show progress indicator (e.g., "Processing GitHub Invitations (3/10)") during processing
+
+  Fixes #1148
+
 ## 1.9.0
 
 ### Minor Changes

package/package.json

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

package/src/telegram-accept-invitations.lib.mjs

@@ -7,7 +7,9 @@
  * Features:
  * - Accepts all pending repository invitations
  * - Accepts all pending organization invitations
- * - Provides detailed feedback on accepted invitations
+ * - Groups output by Repositories and Organizations
+ * - Provides clickable links to repositories and organizations
+ * - Real-time progress updates during processing
  * - Error handling with detailed error messages
  *
  * @see https://docs.github.com/en/rest/collaborators/invitations
@@ -28,6 +30,83 @@ function escapeMarkdown(text) {
   return String(text).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
 }
 
+/**
+ * Build progress message from current state
+ * @param {Object} state - Current state object
+ * @param {string[]} state.acceptedRepos - List of accepted repo names
+ * @param {string[]} state.acceptedOrgs - List of accepted org names
+ * @param {string[]} state.errors - List of errors
+ * @param {number} state.totalRepos - Total number of repo invitations
+ * @param {number} state.totalOrgs - Total number of org invitations
+ * @param {number} state.processedRepos - Number of processed repo invitations
+ * @param {number} state.processedOrgs - Number of processed org invitations
+ * @param {boolean} state.isComplete - Whether processing is complete
+ * @returns {string} Formatted message
+ */
+function buildProgressMessage(state) {
+  const { acceptedRepos, acceptedOrgs, errors, totalRepos, totalOrgs, processedRepos, processedOrgs, isComplete } = state;
+
+  // Calculate totals
+  const totalInvitations = totalRepos + totalOrgs;
+  const processedTotal = processedRepos + processedOrgs;
+  const acceptedTotal = acceptedRepos.length + acceptedOrgs.length;
+
+  // Build header with progress indicator
+  let message = isComplete ? '✅ *GitHub Invitations Processed*\n\n' : `🔄 *Processing GitHub Invitations* \\(${processedTotal}/${totalInvitations}\\)\n\n`;
+
+  // Show Repositories section if any
+  if (acceptedRepos.length > 0 || (!isComplete && totalRepos > 0)) {
+    message += '*Repositories:*\n';
+    for (const repoName of acceptedRepos) {
+      // Create clickable link: [owner/repo](https://github.com/owner/repo)
+      const escapedName = escapeMarkdown(repoName);
+      const escapedLink = escapeMarkdown(`https://github.com/${repoName}`);
+      message += `  • 📦 [${escapedName}](${escapedLink})\n`;
+    }
+    // Show pending indicator if still processing repos
+    if (!isComplete && processedRepos < totalRepos) {
+      const remaining = totalRepos - processedRepos;
+      message += `  • _\\.\\.\\. ${remaining} more pending_\n`;
+    }
+    message += '\n';
+  }
+
+  // Show Organizations section if any
+  if (acceptedOrgs.length > 0 || (!isComplete && totalOrgs > 0)) {
+    message += '*Organizations:*\n';
+    for (const orgName of acceptedOrgs) {
+      // Create clickable link: [org](https://github.com/org)
+      const escapedName = escapeMarkdown(orgName);
+      const escapedLink = escapeMarkdown(`https://github.com/${orgName}`);
+      message += `  • 🏢 [${escapedName}](${escapedLink})\n`;
+    }
+    // Show pending indicator if still processing orgs
+    if (!isComplete && processedOrgs < totalOrgs) {
+      const remaining = totalOrgs - processedOrgs;
+      message += `  • _\\.\\.\\. ${remaining} more pending_\n`;
+    }
+    message += '\n';
+  }
+
+  // Show errors if any
+  if (errors.length > 0) {
+    message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n') + '\n\n';
+  }
+
+  // Show summary
+  if (isComplete) {
+    if (acceptedTotal === 0 && errors.length === 0) {
+      message += 'No pending invitations found\\.';
+    } else if (acceptedTotal > 0 && errors.length === 0) {
+      message += `\n🎉 Successfully accepted ${acceptedTotal} invitation\\(s\\)\\!`;
+    } else if (acceptedTotal > 0 && errors.length > 0) {
+      message += `\n⚠️ Accepted ${acceptedTotal} invitation\\(s\\), ${errors.length} error\\(s\\)\\.`;
+    }
+  }
+
+  return message;
+}
+
 /**
  * Registers the /accept_invites command handler with the bot
  * @param {Object} bot - The Telegraf bot instance
@@ -61,68 +140,97 @@ export function registerAcceptInvitesCommand(bot, options) {
         reply_to_message_id: ctx.message.message_id,
       });
 
-    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations...', { reply_to_message_id: ctx.message.message_id });
-    const accepted = [];
-    const errors = [];
+    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations\\.\\.\\.', {
+      reply_to_message_id: ctx.message.message_id,
+      parse_mode: 'MarkdownV2',
+    });
+
+    // State for tracking progress
+    const state = {
+      acceptedRepos: [],
+      acceptedOrgs: [],
+      errors: [],
+      totalRepos: 0,
+      totalOrgs: 0,
+      processedRepos: 0,
+      processedOrgs: 0,
+      isComplete: false,
+    };
+
+    // Helper to update the message safely
+    const updateMessage = async () => {
+      try {
+        const message = buildProgressMessage(state);
+        await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'MarkdownV2' });
+      } catch (err) {
+        // Ignore "message not modified" errors
+        if (!err.message?.includes('message is not modified')) {
+          VERBOSE && console.log(`[VERBOSE] /accept-invites: Error updating message: ${err.message}`);
+        }
+      }
+    };
 
     try {
       // Fetch repository invitations
       const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
       const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
+      state.totalRepos = repoInvitations.length;
       VERBOSE && console.log(`[VERBOSE] Found ${repoInvitations.length} pending repo invitations`);
 
-      // Accept each repo invitation
+      // Fetch organization invitations
+      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
+      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
+      state.totalOrgs = pendingOrgs.length;
+      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
+
+      // Check if there are any invitations
+      if (state.totalRepos === 0 && state.totalOrgs === 0) {
+        state.isComplete = true;
+        await updateMessage();
+        return;
+      }
+
+      // Update to show we found invitations
+      await updateMessage();
+
+      // Accept each repo invitation with progress updates
       for (const inv of repoInvitations) {
         const repoName = inv.repository?.full_name || 'unknown';
         try {
           await exec(`gh api -X PATCH /user/repository_invitations/${inv.id}`);
-          accepted.push(`📦 Repository: ${repoName}`);
+          state.acceptedRepos.push(repoName);
           VERBOSE && console.log(`[VERBOSE] Accepted repo invitation: ${repoName}`);
         } catch (e) {
-          errors.push(`📦 ${repoName}: ${e.message}`);
+          state.errors.push(`📦 ${repoName}: ${e.message}`);
           VERBOSE && console.log(`[VERBOSE] Failed to accept repo invitation ${repoName}: ${e.message}`);
         }
+        state.processedRepos++;
+        await updateMessage();
       }
 
-      // Fetch organization invitations
-      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
-      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
-      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
-      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
-
-      // Accept each org invitation
+      // Accept each org invitation with progress updates
       for (const membership of pendingOrgs) {
         const orgName = membership.organization?.login || 'unknown';
         try {
           await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
-          accepted.push(`🏢 Organization: ${orgName}`);
+          state.acceptedOrgs.push(orgName);
           VERBOSE && console.log(`[VERBOSE] Accepted org invitation: ${orgName}`);
         } catch (e) {
-          errors.push(`🏢 ${orgName}: ${e.message}`);
+          state.errors.push(`🏢 ${orgName}: ${e.message}`);
           VERBOSE && console.log(`[VERBOSE] Failed to accept org invitation ${orgName}: ${e.message}`);
         }
+        state.processedOrgs++;
+        await updateMessage();
       }
 
-      // Build response message
-      let message = '✅ *GitHub Invitations Processed*\n\n';
-      if (accepted.length === 0 && errors.length === 0) {
-        message += 'No pending invitations found.';
-      } else {
-        if (accepted.length > 0) {
-          message += '*Accepted:*\n' + accepted.map(a => `  • ${escapeMarkdown(a)}`).join('\n') + '\n\n';
-        }
-        if (errors.length > 0) {
-          message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n');
-        }
-        if (accepted.length > 0 && errors.length === 0) {
-          message += `\n🎉 Successfully accepted ${accepted.length} invitation(s)!`;
-        }
-      }
-
-      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
+      // Final update
+      state.isComplete = true;
+      await updateMessage();
     } catch (error) {
       console.error('Error in /accept-invites:', error);
-      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapeMarkdown(error.message)}\n\nMake sure \`gh\` CLI is installed and authenticated.`, { parse_mode: 'Markdown' });
+      const escapedError = escapeMarkdown(error.message);
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapedError}\n\nMake sure \`gh\` CLI is installed and authenticated\\.`, { parse_mode: 'MarkdownV2' });
     }
   });
 }

package/src/telegram-solve-queue.lib.mjs

@@ -34,16 +34,16 @@ import { getCachedClaudeLimits, getCachedGitHubLimits, getCachedMemoryInfo, getC
 export const QUEUE_CONFIG = {
   // Resource thresholds (usage ratios: 0.0 - 1.0)
   // All thresholds use >= comparison (inclusive)
-  RAM_THRESHOLD: 0.65, // Stop if RAM usage >= 65%
+  RAM_THRESHOLD: 0.65, // Enqueue if RAM usage >= 65%
   // CPU threshold uses 5-minute load average, not instantaneous CPU usage
-  CPU_THRESHOLD: 0.75, // Stop if 5-minute load average >= 75% of CPU count
-  DISK_THRESHOLD: 0.95, // One-at-a-time if disk usage >= 95%
+  CPU_THRESHOLD: 0.65, // Enqueue if 5-minute load average >= 65% of CPU count
+  DISK_THRESHOLD: 0.9, // One-at-a-time if disk usage >= 90%
 
   // API limit thresholds (usage ratios: 0.0 - 1.0)
   // All thresholds use >= comparison (inclusive)
-  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.85, // Stop if 5-hour limit >= 85%
+  CLAUDE_5_HOUR_SESSION_THRESHOLD: 0.85, // One-at-a-time if 5-hour limit >= 85%
   CLAUDE_WEEKLY_THRESHOLD: 0.98, // One-at-a-time if weekly limit >= 98%
-  GITHUB_API_THRESHOLD: 0.8, // Stop if GitHub >= 80% with parallel claude
+  GITHUB_API_THRESHOLD: 0.8, // Enqueue if GitHub >= 80% with parallel claude
 
   // Timing
   // MIN_START_INTERVAL_MS: Time to allow solve command to start actual claude process
@@ -431,11 +431,15 @@ export class SolveQueue {
       this.recordThrottle('claude_running');
     }
 
-    // Check system resources (ultimate restrictions - block unconditionally)
-    const resourceCheck = await this.checkSystemResources();
+    // Check system resources (RAM, CPU block unconditionally; disk uses one-at-a-time mode)
+    // See: https://github.com/link-assistant/hive-mind/issues/1155
+    const resourceCheck = await this.checkSystemResources(totalProcessing);
     if (!resourceCheck.ok) {
       reasons.push(...resourceCheck.reasons);
     }
+    if (resourceCheck.oneAtATime) {
+      oneAtATime = true;
+    }
 
     // Check API limits (pass hasRunningClaude and totalProcessing for uniform checking)
     const limitCheck = await this.checkApiLimits(hasRunningClaude, totalProcessing);
@@ -478,17 +482,22 @@ export class SolveQueue {
    * This provides a more stable metric that isn't affected by brief spikes
    * during claude process startup.
    *
-   * Note: System resource thresholds are ultimate restrictions - they block unconditionally
-   * when triggered. Unlike Claude API thresholds which allow one command at a time via
-   * totalProcessing check, system resources block all new commands immediately.
-   * See: https://github.com/link-assistant/hive-mind/issues/1133
+   * Resource threshold modes:
+   * - RAM_THRESHOLD: Enqueue mode - blocks all commands unconditionally
+   * - CPU_THRESHOLD: Enqueue mode - blocks all commands unconditionally
+   * - DISK_THRESHOLD: One-at-a-time mode - allows exactly one command when nothing is processing
+   *
+   * See: https://github.com/link-assistant/hive-mind/issues/1155
    *
-   * @returns {Promise<{ok: boolean, reasons: string[]}>}
+   * @param {number} totalProcessing - Total processing count (queue + external claude processes)
+   * @returns {Promise<{ok: boolean, reasons: string[], oneAtATime: boolean}>}
    */
-  async checkSystemResources() {
+  async checkSystemResources(totalProcessing = 0) {
     const reasons = [];
+    let oneAtATime = false;
 
     // Check RAM (using cached value)
+    // Enqueue mode: blocks all commands unconditionally
     const memResult = await getCachedMemoryInfo(this.verbose);
     if (memResult.success) {
       const usedRatio = memResult.memory.usedPercentage / 100;
@@ -499,6 +508,7 @@ export class SolveQueue {
     }
 
     // Check CPU using 5-minute load average (more stable than 1-minute)
+    // Enqueue mode: blocks all commands unconditionally
     // Cache TTL is 2 minutes, which is appropriate for this metric
     const cpuResult = await getCachedCpuInfo(this.verbose);
     if (cpuResult.success) {
@@ -522,22 +532,26 @@ export class SolveQueue {
     }
 
     // Check disk space (using cached value)
-    // Note: Disk threshold is an ultimate restriction - it blocks unconditionally when triggered
-    // Unlike CLAUDE_5_HOUR_SESSION_THRESHOLD and CLAUDE_WEEKLY_THRESHOLD which use totalProcessing
-    // to allow one command at a time, disk threshold blocks all new commands immediately
-    // See: https://github.com/link-assistant/hive-mind/issues/1133
+    // One-at-a-time mode: allows exactly one command when nothing is processing
+    // Unlike RAM and CPU which block unconditionally, disk uses one-at-a-time mode
+    // because we cannot predict how much disk space a task will use
+    // See: https://github.com/link-assistant/hive-mind/issues/1155
     const diskResult = await getCachedDiskInfo(this.verbose);
     if (diskResult.success) {
       // Calculate usage from free percentage
       const usedPercent = 100 - diskResult.diskSpace.freePercentage;
       const usedRatio = usedPercent / 100;
       if (usedRatio >= QUEUE_CONFIG.DISK_THRESHOLD) {
-        reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD));
+        oneAtATime = true;
         this.recordThrottle('disk_high');
+        // Only block if something is already processing (one-at-a-time mode)
+        if (totalProcessing > 0) {
+          reasons.push(formatWaitingReason('disk', usedPercent, QUEUE_CONFIG.DISK_THRESHOLD) + ' (waiting for current command)');
+        }
       }
     }
 
-    return { ok: reasons.length === 0, reasons };
+    return { ok: reasons.length === 0, reasons, oneAtATime };
   }
 
   /**