@link-assistant/hive-mind 1.21.3 → 1.22.0

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

@@ -43,13 +43,14 @@ export const QueueItemStatus = {
 };
 
 /**
- * Count running claude processes
+ * Count running processes by name
+ * @param {string} processName - Process name to search for (e.g., 'claude', 'agent')
  * @param {boolean} verbose - Whether to log verbose output
  * @returns {Promise<{count: number, processes: string[]}>}
  */
-export async function getRunningClaudeProcesses(verbose = false) {
+export async function getRunningProcesses(processName, verbose = false) {
   try {
-    const { stdout } = await execAsync('pgrep -l -x claude 2>/dev/null || true');
+    const { stdout } = await execAsync(`pgrep -l -x ${processName} 2>/dev/null || true`);
     const lines = stdout
       .trim()
       .split('\n')
@@ -60,13 +61,13 @@ export async function getRunningClaudeProcesses(verbose = false) {
         const parts = line.trim().split(/\s+/);
         return {
           pid: parts[0],
-          name: parts.slice(1).join(' ') || 'claude',
+          name: parts.slice(1).join(' ') || processName,
         };
       })
       .filter(p => p.pid);
 
     if (verbose) {
-      console.log(`[VERBOSE] /solve_queue found ${processes.length} running claude processes`);
+      console.log(`[VERBOSE] /solve_queue found ${processes.length} running ${processName} processes`);
       if (processes.length > 0) {
         console.log(`[VERBOSE] /solve_queue processes: ${JSON.stringify(processes)}`);
       }
@@ -78,12 +79,30 @@ export async function getRunningClaudeProcesses(verbose = false) {
     };
   } catch (error) {
     if (verbose) {
-      console.error('[VERBOSE] /solve_queue error counting claude processes:', error.message);
+      console.error(`[VERBOSE] /solve_queue error counting ${processName} processes:`, error.message);
     }
     return { count: 0, processes: [] };
   }
 }
 
+/**
+ * Count running claude processes
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningClaudeProcesses(verbose = false) {
+  return getRunningProcesses('claude', verbose);
+}
+
+/**
+ * Count running agent processes
+ * @param {boolean} verbose - Whether to log verbose output
+ * @returns {Promise<{count: number, processes: string[]}>}
+ */
+export async function getRunningAgentProcesses(verbose = false) {
+  return getRunningProcesses('agent', verbose);
+}
+
 /**
  * Format a threshold as percentage for display
  * @param {number} ratio - Ratio (0.0 - 1.0)
@@ -93,6 +112,33 @@ function formatThresholdPercent(ratio) {
   return `${Math.round(ratio * 100)}%`;
 }
 
+/**
+ * Format milliseconds into human-readable duration
+ * Shows days, hours, minutes, and seconds as appropriate.
+ * Examples: "5h 43m 23s", "2m 15s", "45s", "1d 3h 12m 5s"
+ *
+ * @param {number} ms - Duration in milliseconds
+ * @returns {string} Human-readable duration
+ * @see https://github.com/link-assistant/hive-mind/issues/1267
+ */
+export function formatDuration(ms) {
+  if (ms < 0) ms = 0;
+
+  const totalSeconds = Math.floor(ms / 1000);
+  const days = Math.floor(totalSeconds / 86400);
+  const hours = Math.floor((totalSeconds % 86400) / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const seconds = totalSeconds % 60;
+
+  const parts = [];
+  if (days > 0) parts.push(`${days}d`);
+  if (hours > 0) parts.push(`${hours}h`);
+  if (minutes > 0) parts.push(`${minutes}m`);
+  if (seconds > 0 || parts.length === 0) parts.push(`${seconds}s`);
+
+  return parts.join(' ');
+}
+
 /**
  * Generate human-readable waiting reason based on threshold violation
  * @param {string} metric - The metric name (ram, cpu, disk, etc.)
@@ -1035,7 +1081,11 @@ export class SolveQueue {
           const itemCheck = await this.canStartCommand({ tool: item.tool });
           const previousStatus = item.status;
           const previousReason = item.waitingReason;
-          item.setWaiting(itemCheck.reason || 'Waiting in queue');
+          // Use rejectReason when threshold strategy is 'reject', otherwise use reason
+          // This ensures disk-full and other rejection reasons are shown properly
+          // See: https://github.com/link-assistant/hive-mind/issues/1267
+          const waitReason = itemCheck.rejectReason || itemCheck.reason || 'Waiting in queue';
+          item.setWaiting(waitReason);
 
           // Update message if status/reason changed or it's time for periodic update
           const shouldUpdate = previousStatus !== item.status || previousReason !== item.waitingReason || this.shouldUpdateMessage(item);
@@ -1158,74 +1208,113 @@ export class SolveQueue {
   }
 
   /**
-   * Format queue status for display
-   * Shows per-tool queue counts.
-   * @returns {string}
+   * Format queue status for display in /limits command
+   * Shows per-tool queue breakdown with processing counts.
+   *
+   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
+   * This is because items transition quickly through the processing state, but the actual
+   * work happens in the spawned system process (claude, agent, etc.).
+   *
+   * Output format:
+   * ```
+   * Queues
+   * claude (pending: 6, processing: 0)
+   * agent (pending: 2, processing: 0)
+   * ```
+   *
+   * @returns {Promise<string>}
    * @see https://github.com/link-assistant/hive-mind/issues/1159
+   * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
-  formatStatus() {
-    const stats = this.getStats();
-    if (stats.queued > 0 || stats.processing > 0) {
-      // Show per-tool breakdown if there are items
-      const toolBreakdown = Object.entries(stats.queuedByTool)
-        .filter(entry => entry[1] > 0)
-        .map(([tool, count]) => `${tool}: ${count}`)
-        .join(', ');
-      const queueInfo = toolBreakdown ? ` (${toolBreakdown})` : '';
-      return `Solve Queue: ${stats.queued} pending${queueInfo}, ${stats.processing} processing\n`;
+  async formatStatus() {
+    // Get actual process counts for each tool queue
+    // The "processing" count is the number of running system processes, not queue internal state
+    // This ensures users see accurate counts of what's actually running
+    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
+
+    const processCounts = {
+      claude: claudeProcs.count,
+      agent: agentProcs.count,
+    };
+
+    // Always show per-tool breakdown for all known queues
+    let message = 'Queues\n';
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      const pending = toolQueue.length;
+      const processing = processCounts[tool] || 0;
+      message += `${tool} (pending: ${pending}, processing: ${processing})\n`;
     }
-    return 'Solve Queue: empty\n';
+
+    return message;
   }
 
   /**
    * Format detailed queue status for Telegram message
-   * Shows per-tool queue breakdown.
-   * @returns {string}
+   * Groups output by tool queue, shows first 5 items per queue, and uses human-readable time.
+   *
+   * Processing count = actual running system processes (via pgrep), not items in queue processing state.
+   * This is because items transition quickly through the processing state, but the actual
+   * work happens in the spawned system process (claude, agent, etc.).
+   *
+   * Output format:
+   * ```
+   * 📋 Solve Queue Status
+   *
+   * claude (pending: 6, processing: 0)
+   * • url1 (waiting, 5h 43m 23s)
+   *   └ RAM usage is 70% (threshold: 65%)
+   * • url2 (queued, 2m 15s)
+   *
+   * agent (pending: 2, processing: 0)
+   * • url3 (waiting, 1h 2m 5s)
+   * ```
+   *
+   * @returns {Promise<string>}
    * @see https://github.com/link-assistant/hive-mind/issues/1159
+   * @see https://github.com/link-assistant/hive-mind/issues/1267
    */
-  formatDetailedStatus() {
+  async formatDetailedStatus() {
     const stats = this.getStats();
-    const summary = this.getQueueSummary();
 
-    let message = '📋 *Solve Queue Status*\n\n';
-    message += `Pending: ${stats.queued}`;
-
-    // Add per-tool breakdown
-    const toolBreakdown = Object.entries(stats.queuedByTool)
-      .filter(entry => entry[1] > 0)
-      .map(([tool, count]) => `${tool}: ${count}`)
-      .join(', ');
-    if (toolBreakdown) {
-      message += ` (${toolBreakdown})`;
-    }
-    message += '\n';
+    // Get actual process counts for each tool queue
+    // The "processing" count is the number of running system processes, not queue internal state
+    // This ensures users see accurate counts of what's actually running
+    const claudeProcs = await getRunningClaudeProcesses(this.verbose);
+    const agentProcs = await getRunningAgentProcesses(this.verbose);
 
-    message += `Processing: ${stats.processing}\n`;
-    message += `Completed: ${stats.completed}\n`;
-    message += `Failed: ${stats.failed}\n\n`;
+    const processCounts = {
+      claude: claudeProcs.count,
+      agent: agentProcs.count,
+    };
 
-    if (summary.processing.length > 0) {
-      message += '*Currently Processing:*\n';
-      for (const item of summary.processing) {
-        message += `• ${item.url} [${item.tool}]\n`;
-      }
-      message += '\n';
-    }
+    let message = '📋 *Solve Queue Status*\n\n';
 
-    if (summary.pending.length > 0) {
-      message += '*Waiting in Queue:*\n';
-      for (const item of summary.pending.slice(0, 5)) {
-        const waitSeconds = Math.floor(item.waitTime / 1000);
-        message += `• ${item.url} [${item.tool}] (${item.status}, ${waitSeconds}s)\n`;
+    // Show per-tool queue breakdown with items grouped by queue
+    for (const [tool, toolQueue] of Object.entries(this.queues)) {
+      const pending = toolQueue.length;
+      const processing = processCounts[tool] || 0;
+      message += `*${tool}* (pending: ${pending}, processing: ${processing})\n`;
+
+      // Show first 5 queued items for this tool
+      const displayItems = toolQueue.slice(0, 5);
+      for (const item of displayItems) {
+        const waitTime = formatDuration(item.getWaitTime());
+        message += `  • ${item.url} (${item.status}, ${waitTime})\n`;
         if (item.waitingReason) {
-          message += `  └ ${item.waitingReason}\n`;
+          message += `    └ ${item.waitingReason}\n`;
         }
       }
-      if (summary.pending.length > 5) {
-        message += `  ... and ${summary.pending.length - 5} more\n`;
+      if (toolQueue.length > 5) {
+        message += `    ... and ${toolQueue.length - 5} more\n`;
       }
+
+      message += '\n';
     }
 
+    // Summary stats
+    message += `Completed: ${stats.completed}, Failed: ${stats.failed}\n`;
+
     return message;
   }
 }
@@ -1275,8 +1364,11 @@ export default {
   SolveQueueItem,
   getSolveQueue,
   resetSolveQueue,
+  getRunningProcesses,
   getRunningClaudeProcesses,
+  getRunningAgentProcesses,
   createQueueExecuteCallback,
+  formatDuration,
   QUEUE_CONFIG,
   QueueItemStatus,
 };