@link-assistant/hive-mind 1.54.8 → 1.56.0

package/src/claude.lib.mjs

@@ -11,6 +11,7 @@ import { reportError } from './sentry.lib.mjs';
 import { timeouts, retryLimits, claudeCode, getClaudeEnv, getThinkingLevelToTokens, getTokensToThinkingLevel, supportsThinkingBudget, DEFAULT_MAX_THINKING_BUDGET, getMaxOutputTokensForModel } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { createInteractiveHandler } from './interactive-mode.lib.mjs';
+import { setupBidirectionalHandler, finalizeBidirectionalHandler, validateBidirectionalModeConfig, attachStreamingInput } from './bidirectional-interactive.lib.mjs';
 import { initProgressMonitoring } from './solve.progress-monitoring.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
 import Decimal from 'decimal.js-light';
@@ -632,6 +633,10 @@ export const executeClaudeCommand = async params => {
     repo,
     prNumber,
   } = params;
+  // Issue #817: Apply bidirectional-mode composition and tool-support validation before running.
+  // This may enable argv.interactiveMode, argv.acceptIncommingCommentsAsInput, and
+  // argv.excludeAllOwnIncommingCommentsFromInput when --bidirectional-interactive-mode is set.
+  await validateBidirectionalModeConfig(argv, log);
   // Issue #1331: Unified retry configuration for all transient API errors
   // (Overloaded, 503 Network Error, Internal Server Error) - same params, all with session preservation
   let retryCount = 0;
@@ -715,6 +720,9 @@ export const executeClaudeCommand = async params => {
     } else if (argv.interactiveMode) {
       await log('⚠️ Interactive mode: Disabled - missing PR info (owner/repo/prNumber)', { verbose: true });
     }
+    // Issue #817: Set up bidirectional handler when --accept-incomming-comments-as-input
+    // (or composite --bidirectional-interactive-mode) is enabled. Returns null when inactive.
+    const bidirectionalHandler = await setupBidirectionalHandler({ argv, owner, repo, prNumber, $, log });
     const progressMonitor = await initProgressMonitoring(argv, { owner, repo, prNumber, $, log }); // works with or without --interactive-mode
     let execCommand;
     const mappedModel = mapModelToId(argv.model);
@@ -722,6 +730,12 @@ export const executeClaudeCommand = async params => {
     const effectiveModel = resolvedPlanModel ? 'opusplan' : mappedModel;
     const resolvedExecutionModel = resolvedPlanModel ? mappedModel : undefined;
     let claudeArgs = `--output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel}`;
+    // Declare queuedFeedback for use in catch/finally blocks and return value
+    let queuedFeedback = [];
+    // Issue #817: When --accept-incomming-comments-as-input is set and we are
+    // not resuming a prior session, drive Claude via NDJSON stream-json input
+    // so incoming PR comments can be streamed as additional user turns.
+    const streamingInput = !!(argv.acceptIncommingCommentsAsInput && bidirectionalHandler && !argv.resume);
     if (argv.resume) {
       await log(`🔄 Resuming from session: ${argv.resume}`);
       claudeArgs = `--resume ${argv.resume} ${claudeArgs}`;
@@ -730,7 +744,12 @@ export const executeClaudeCommand = async params => {
     const { mcpConfigPath, disallowedToolsList } = await resolveClaudeSessionToolFlags({ argv, log, fallbackBuildMcpConfigWithoutPlaywright: buildMcpConfigWithoutPlaywright });
     if (mcpConfigPath) claudeArgs += ` --strict-mcp-config --mcp-config "${mcpConfigPath}"`;
     if (disallowedToolsList.length) claudeArgs += ` --disallowedTools ${disallowedToolsList.join(' ')}`;
-    claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+    if (streamingInput) {
+      // Prompt is delivered as the first NDJSON frame on stdin (not as -p).
+      claudeArgs += ` -p --input-format stream-json --append-system-prompt "${escapedSystemPrompt}"`;
+    } else {
+      claudeArgs += ` -p "${escapedPrompt}" --append-system-prompt "${escapedSystemPrompt}"`;
+    }
     const fullCommand = `(cd "${tempDir}" && ${claudePath} ${claudeArgs} | jq -c .)`;
     await log(`\n${formatAligned('📝', 'Raw command:', '')}`);
     await log(`${fullCommand}`);
@@ -741,7 +760,9 @@ export const executeClaudeCommand = async params => {
     }
     try {
       const { thinkingBudget: resolvedThinkingBudget, thinkLevel, isNewVersion, maxBudget } = await resolveThinkingSettings(argv, log);
-      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent });
+      // Issue #817: Streaming mode sets exitAfterStopDelayMs=60000 so the
+      // headless Claude process stays alive between NDJSON turns.
+      const claudeEnv = getClaudeEnv({ thinkingBudget: resolvedThinkingBudget, model: effectiveModel, thinkLevel, maxBudget, planModel: resolvedPlanModel, executionModel: resolvedExecutionModel, showThinkingContent: argv.showThinkingContent, exitAfterStopDelayMs: streamingInput ? 60_000 : undefined });
       if (argv.verbose) claudeEnv.ANTHROPIC_LOG = 'debug';
       const modelMaxOutputTokens = getMaxOutputTokensForModel(effectiveModel);
       if (argv.verbose) {
@@ -758,9 +779,18 @@ export const executeClaudeCommand = async params => {
       if (argv.resume) {
         const simpleEscapedPrompt = prompt.replace(/"/g, '\\"');
         execCommand = $({ cwd: tempDir, mirror: false, env: claudeEnv })`${claudePath} --resume ${argv.resume} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} -p "${simpleEscapedPrompt}" --append-system-prompt "${simpleEscapedSystem}"`;
+      } else if (streamingInput) {
+        // Issue #817: Drive Claude via --input-format stream-json on a pipe
+        // stdin. Initial prompt + later PR comments are written as NDJSON
+        // frames by attachStreamingInput (see bidirectional-interactive.lib.mjs).
+        const streamingInputArgs = ['-p', '--input-format', 'stream-json'];
+        execCommand = $({ cwd: tempDir, stdin: 'pipe', mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} ${streamingInputArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       } else {
         execCommand = $({ cwd: tempDir, stdin: prompt, mirror: false, env: claudeEnv })`${claudePath} --output-format stream-json --verbose --dangerously-skip-permissions --model ${effectiveModel} ${mcpDisableArgs} ${disallowedToolsArgs} --append-system-prompt "${simpleEscapedSystem}"`;
       }
+      if (streamingInput) {
+        await attachStreamingInput(bidirectionalHandler, execCommand, prompt, log, !!argv.verbose);
+      }
       await log(`${formatAligned('📋', 'Command details:', '')}`);
       await log(formatAligned('📂', 'Working directory:', tempDir, 2));
       await log(formatAligned('🌿', 'Branch:', branchName, 2));
@@ -1116,6 +1146,8 @@ export const executeClaudeCommand = async params => {
         }
       }
 
+      // Issue #817: Stop bidirectional mode monitoring and collect queued feedback
+      queuedFeedback = await finalizeBidirectionalHandler(bidirectionalHandler, log);
       // Issues #1331, #1353, #1472/#1475: Unified transient error retry (exponential backoff, session preservation)
       const isTransientError = isStartupTimeout || isActivityTimeout || isOverloadError || isInternalServerError || is503Error || isRequestTimeout || (lastMessage.includes('API Error: 500') && (lastMessage.includes('Overloaded') || lastMessage.includes('Internal server error'))) || (lastMessage.includes('API Error: 529') && (lastMessage.includes('overloaded_error') || lastMessage.includes('Overloaded'))) || (lastMessage.includes('api_error') && lastMessage.includes('Overloaded')) || (lastMessage.includes('overloaded_error') && lastMessage.includes('Overloaded')) || lastMessage.includes('API Error: 503') || (lastMessage.includes('503') && (lastMessage.includes('upstream connect error') || lastMessage.includes('remote connection failure'))) || lastMessage === 'Request timed out' || lastMessage.includes('Request timed out');
       if ((commandFailed || isTransientError) && isTransientError) {
@@ -1141,6 +1173,7 @@ export const executeClaudeCommand = async params => {
             is503Error,
             anthropicTotalCostUSD,
             resultSummary,
+            queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
         if (retryCount < maxRetries) {
@@ -1183,6 +1216,7 @@ export const executeClaudeCommand = async params => {
             is503Error, // preserve for callers that check this
             anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
             resultSummary, // Issue #1263: Include result summary
+            queuedFeedback, // Issue #817: Bidirectional mode feedback
           };
         }
       }
@@ -1242,6 +1276,7 @@ export const executeClaudeCommand = async params => {
           errorDuringExecution,
           anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
           resultSummary, // Issue #1263: Include result summary
+          queuedFeedback, // Issue #817: Bidirectional mode feedback
         };
       }
       // Issue #1088/#1351: Log execution result status
@@ -1330,6 +1365,7 @@ export const executeClaudeCommand = async params => {
         resultModelUsage, // Issue #1454
         streamTokenUsage: streamTokenUsage.eventCount > 0 ? streamTokenUsage : null, // Issue #1491
         subAgentCalls: subAgentCalls.length > 0 ? subAgentCalls : null, // Issue #1590
+        queuedFeedback, // Issue #817: Bidirectional mode feedback
       };
     } catch (error) {
       reportError(error, {
@@ -1371,6 +1407,7 @@ export const executeClaudeCommand = async params => {
         toolUseCount,
         anthropicTotalCostUSD, // Issue #1104: Include cost even on failure
         resultSummary, // Issue #1263: Include result summary
+        queuedFeedback, // Issue #817: Bidirectional mode feedback
       };
     }
   }; // End of executeWithRetry function

package/src/config.lib.mjs

@@ -463,6 +463,14 @@ export const getClaudeEnv = (options = {}) => {
   if (options.showThinkingContent) {
     env.CLAUDE_CODE_SHOW_THINKING = '1';
   }
+  // Issue #817: When bidirectional streaming input is enabled, keep the headless
+  // Claude process alive between turns so newly arriving PR comments can be
+  // streamed into stdin as additional user messages. Without this env var the
+  // process would exit as soon as the first --input-format stream-json frame
+  // is processed. Default is 1 minute (60000ms), matching the reference gist.
+  if (options.exitAfterStopDelayMs) {
+    env.CLAUDE_CODE_EXIT_AFTER_STOP_DELAY_MS = String(options.exitAfterStopDelayMs);
+  }
   // Set ANTHROPIC_DEFAULT_OPUS_MODEL when planModel is specified (Issue #1223)
   // This tells Claude Code which model to use during plan mode in opusplan
   if (options.planModel) {

package/src/hive-screens.lib.mjs

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+/**
+ * Shared runner for the `hive-screens` bin command. Scans detached GNU
+ * screen sessions for completed solve runs and lists, enters, or closes
+ * them. Ports the `hive-screens.sh` script that previously lived in
+ * README.md, and keeps a single matching function so that `--list` is
+ * a safe preview for `--close` / `--enter`.
+ *
+ * See issue #1649.
+ */
+
+import { exec as execCallback } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(execCallback);
+
+export const HIVE_SCREENS_HELP = `Usage: hive-screens (--list | --enter | --close) [--oldest|--newest|--all]
+
+Scan detached GNU screen sessions for completed solve runs and either list,
+enter, or close them. A session matches when its scrollback contains both
+"process completed" and either "pr is mergeable!" or "pr merged!" (case
+insensitive) — the exact predicate from the legacy hive-screens.sh script.
+
+Actions (one required):
+      --list           Print matching sessions without touching them
+      --enter          Attach to the selected match (blocking)
+      --close          Send \`exit\\n\` to the selected match so it terminates
+
+Selection (optional, default: --oldest):
+      --oldest         Act on the oldest match (default)
+      --newest         Act on the newest match
+      --all            Act on every match in oldest-first order
+
+Options:
+  -h, --help           Show this help and exit
+
+Examples:
+  hive-screens --list                   # safe preview of matches
+  hive-screens --list --all             # preview every match
+  hive-screens --close --oldest         # close the oldest finished run
+  hive-screens --enter --newest         # attach to the newest finished run
+
+Reference: https://github.com/link-assistant/hive-mind/issues/1649
+`;
+
+const ACTION_FLAGS = new Set(['--enter', '--close', '--list']);
+const SELECTION_FLAGS = new Set(['--oldest', '--newest', '--all']);
+
+/**
+ * Parse the argv for `hive-screens`. Returns the parsed flags plus an
+ * `error` string when validation fails (so callers can print it and exit
+ * with a non-zero status without throwing).
+ */
+export const parseHiveScreensArgs = argv => {
+  const result = {
+    enter: false,
+    close: false,
+    list: false,
+    selection: null,
+    help: false,
+    error: null,
+  };
+
+  for (const arg of argv) {
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+      continue;
+    }
+    if (ACTION_FLAGS.has(arg)) {
+      if (arg === '--enter') result.enter = true;
+      else if (arg === '--close') result.close = true;
+      else result.list = true;
+      continue;
+    }
+    if (SELECTION_FLAGS.has(arg)) {
+      if (result.selection && result.selection !== arg.slice(2)) {
+        result.error = `Conflicting selection flags: --${result.selection} and ${arg}`;
+        return result;
+      }
+      result.selection = arg.slice(2);
+      continue;
+    }
+    result.error = `Unknown option: ${arg}`;
+    return result;
+  }
+
+  if (result.help) return result;
+
+  const actions = [result.enter, result.close, result.list].filter(Boolean).length;
+  if (actions === 0) {
+    result.error = 'Must specify --list, --enter, or --close';
+    return result;
+  }
+  if (actions > 1) {
+    result.error = 'Specify only one of --list, --enter, --close';
+    return result;
+  }
+
+  if (!result.selection) result.selection = 'oldest';
+  return result;
+};
+
+/**
+ * List detached screen sessions in oldest-first order. GNU screen prints
+ * them newest-first, so we reverse to mirror `sort -n` (ascending PID) on
+ * the typical `NNNNN.name` session names.
+ */
+export const listDetachedSessions = async ({ exec = execAsync } = {}) => {
+  let stdout = '';
+  try {
+    ({ stdout } = await exec('screen -ls'));
+  } catch (err) {
+    // `screen -ls` exits 1 when there are no sessions. It still prints the
+    // session header to stdout, so keep parsing whatever we got.
+    stdout = err.stdout || '';
+  }
+  const sessions = [];
+  for (const rawLine of stdout.split('\n')) {
+    const line = rawLine.trim();
+    if (!/\((?:Detached|Attached)\)/i.test(line)) continue;
+    if (!/Detached/i.test(line)) continue;
+    const match = line.match(/^(\S+)/);
+    if (match) sessions.push(match[1]);
+  }
+  return sessions.sort((a, b) => {
+    const na = parseInt(a, 10);
+    const nb = parseInt(b, 10);
+    if (Number.isNaN(na) || Number.isNaN(nb)) return a.localeCompare(b);
+    return na - nb;
+  });
+};
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const stripNonPrintable = text => text.replace(/[^\t\n\r\x20-\x7E]/g, '');
+
+/**
+ * Capture the scrollback of a single screen session. Mirrors the sh
+ * script: bump scrollback to 200000, settle, `hardcopy -h`, read, strip.
+ */
+export const captureSessionScrollback = async (session, { exec = execAsync, fsModule = fs, tmpDir = os.tmpdir(), scrollback = 200000, settleMs = 150 } = {}) => {
+  const tmpFile = path.join(tmpDir, `hive-screens-${session}-${Date.now()}-${Math.random().toString(36).slice(2)}.hardcopy`);
+  const shellSession = session.replace(/'/g, "'\\''");
+  const shellTmp = tmpFile.replace(/'/g, "'\\''");
+  try {
+    await exec(`screen -S '${shellSession}' -X scrollback ${scrollback}`).catch(() => {});
+    if (settleMs > 0) await sleep(settleMs);
+    await exec(`screen -S '${shellSession}' -X hardcopy -h '${shellTmp}'`).catch(() => {});
+    let raw = '';
+    try {
+      raw = await fsModule.readFile(tmpFile, 'utf-8');
+    } catch {
+      raw = '';
+    }
+    return stripNonPrintable(raw);
+  } finally {
+    await fsModule.unlink(tmpFile).catch(() => {});
+  }
+};
+
+/**
+ * The single source of truth for session matching. `--list`, `--enter`,
+ * and `--close` all route through this predicate, so a session visible in
+ * `--list` is guaranteed to be actionable by the other two flags.
+ */
+export const sessionMatches = text => {
+  if (!text) return { matched: false, logPath: null, issueUrl: null };
+  const hasCompletion = /process completed/i.test(text);
+  const hasMerge = /pr is mergeable!|pr merged!/i.test(text);
+  if (!hasCompletion || !hasMerge) {
+    return { matched: false, logPath: null, issueUrl: null };
+  }
+  const logMatches = [...text.matchAll(/Full log file:\s*(\S+)/gi)];
+  const issueMatches = [...text.matchAll(/Issue:\s*(https:\/\/github\.com\/\S+)/gi)];
+  return {
+    matched: true,
+    logPath: logMatches.length ? logMatches[logMatches.length - 1][1] : null,
+    issueUrl: issueMatches.length ? issueMatches[issueMatches.length - 1][1] : null,
+  };
+};
+
+/**
+ * Scan every detached session and return the ones that pass
+ * `sessionMatches`, in the requested order.
+ */
+export const findMatchingSessions = async ({ exec = execAsync, fsModule = fs, tmpDir = os.tmpdir(), order = 'oldest', captureOptions = {} } = {}) => {
+  const sessions = await listDetachedSessions({ exec });
+  const ordered = order === 'newest' ? [...sessions].reverse() : sessions;
+  const matches = [];
+  for (const session of ordered) {
+    const text = await captureSessionScrollback(session, { exec, fsModule, tmpDir, ...captureOptions });
+    const result = sessionMatches(text);
+    if (result.matched) {
+      matches.push({ session, logPath: result.logPath, issueUrl: result.issueUrl });
+    }
+  }
+  return matches;
+};
+
+/**
+ * Apply `--oldest / --newest / --all` to the ordered match list produced
+ * by `findMatchingSessions`. The orderer already did the directional
+ * sort, so picking element 0 is always "the selected one" in that order.
+ */
+export const selectMatches = (matches, selection) => {
+  if (!matches.length) return [];
+  if (selection === 'all') return matches;
+  return [matches[0]];
+};
+
+const printSession = ({ session, logPath, issueUrl }, { log }) => {
+  log(`Session: ${session}`);
+  log(logPath ? `Log: ${logPath}` : 'Log: (not found)');
+  log(issueUrl ? `Issue: ${issueUrl}` : 'Issue: (not found)');
+};
+
+const SEPARATOR = '-----------------------------------';
+
+/**
+ * Top-level orchestrator used by the bin. `deps` is injected so tests can
+ * stub `exec`, `fs`, stdio, and process spawning without touching real
+ * screen sessions.
+ */
+export const runHiveScreens = async (argv, deps = {}) => {
+  const { exec = execAsync, fsModule = fs, tmpDir = os.tmpdir(), log = (...args) => console.log(...args), error = (...args) => console.error(...args), spawnScreen, captureOptions } = deps;
+
+  const args = parseHiveScreensArgs(argv);
+  if (args.help) {
+    log(HIVE_SCREENS_HELP);
+    return 0;
+  }
+  if (args.error) {
+    error(args.error);
+    return 1;
+  }
+
+  const order = args.selection === 'newest' ? 'newest' : 'oldest';
+  const matches = await findMatchingSessions({ exec, fsModule, tmpDir, order, captureOptions });
+
+  if (!matches.length) {
+    log('No matching sessions');
+    return 0;
+  }
+
+  const selected = selectMatches(matches, args.selection);
+
+  for (const match of selected) {
+    printSession(match, { log });
+    if (args.enter) {
+      log(`Entering ${match.session}`);
+      if (spawnScreen) {
+        await spawnScreen(match.session);
+      } else {
+        await attachScreen(match.session);
+      }
+      log(`Left ${match.session}`);
+    }
+    if (args.close) {
+      log(`Closing ${match.session}`);
+      const shellSession = match.session.replace(/'/g, "'\\''");
+      await exec(`screen -S '${shellSession}' -X stuff $'exit\\n'`).catch(err => {
+        error(`Failed to send exit to ${match.session}: ${err.message}`);
+      });
+    }
+    log(SEPARATOR);
+  }
+
+  return 0;
+};
+
+/**
+ * Default `--enter` side-effect: spawn `screen -r <session>` attached to
+ * the parent stdio so the user can actually interact with it. Split from
+ * `runHiveScreens` so tests can inject a no-op spawn.
+ */
+const attachScreen = async session => {
+  const { spawn } = await import('node:child_process');
+  return new Promise((resolve, reject) => {
+    const child = spawn('screen', ['-r', session], { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('exit', () => resolve());
+  });
+};

package/src/hive-screens.mjs

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+/**
+ * `hive-screens` — list, enter, or close detached GNU screen sessions
+ * produced by `solve` / `hive` runs that have completed a mergeable PR.
+ *
+ * Replaces the embedded `hive-screens.sh` script that previously lived
+ * in README.md. The matching predicate is shared across `--list`,
+ * `--enter`, and `--close`, so any session visible under `--list` is
+ * guaranteed to be actionable by the other two flags.
+ *
+ * See issue #1649.
+ */
+
+import { runHiveScreens } from './hive-screens.lib.mjs';
+
+const exitCode = await runHiveScreens(process.argv.slice(2));
+process.exit(exitCode);

package/src/solve.config.lib.mjs

@@ -334,6 +334,22 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: '[EXPERIMENTAL] Post tool output as PR comments in real-time. Supported for --tool claude and --tool codex.',
     default: false,
   },
+  // Issue #817: Bidirectional interactive options
+  'accept-incomming-comments-as-input': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Accept new PR/issue comments as input for Claude during execution (excludes outgoing comments generated by solve itself). Does not require --interactive-mode; disabled by default. Only supported for --tool claude.',
+    default: false,
+  },
+  'exclude-all-own-incomming-comments-from-input': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] When combined with --accept-incomming-comments-as-input, also exclude comments written by the same GitHub user that solve runs as (prevents self-talk). Disabled by default.',
+    default: false,
+  },
+  'bidirectional-interactive-mode': {
+    type: 'boolean',
+    description: '[EXPERIMENTAL] Convenience flag that enables --interactive-mode, --accept-incomming-comments-as-input and --exclude-all-own-incomming-comments-from-input together. Only supported for --tool claude.',
+    default: false,
+  },
   'prompt-explore-sub-agent': {
     type: 'boolean',
     description: 'Encourage AI to use Explore-style sub-agent workflow for codebase exploration. Supported for --tool claude and --tool codex.',