@link-assistant/hive-mind 0.39.0

package/src/solve.config.lib.mjs

@@ -0,0 +1,342 @@
+// CLI configuration module for solve command
+// Extracted from solve.mjs to keep files under 1500 lines
+
+// This module expects 'use' to be passed in from the parent module
+// to avoid duplicate use-m initialization issues
+
+// Note: Strict options validation is now handled by yargs built-in .strict() mode (see below)
+// This approach was adopted per issue #482 feedback to minimize custom code maintenance
+
+// Export an initialization function that accepts 'use'
+export const initializeConfig = async (use) => {
+  // Import yargs with specific version for hideBin support
+  const yargsModule = await use('yargs@17.7.2');
+  const yargs = yargsModule.default || yargsModule;
+  const { hideBin } = await use('yargs@17.7.2/helpers');
+
+  return { yargs, hideBin };
+};
+
+// Function to create yargs configuration - avoids duplication
+export const createYargsConfig = (yargsInstance) => {
+  return yargsInstance
+    .usage('Usage: solve.mjs <issue-url> [options]')
+    .command('$0 <issue-url>', 'Solve a GitHub issue or pull request', (yargs) => {
+      yargs.positional('issue-url', {
+        type: 'string',
+        description: 'The GitHub issue URL to solve'
+      });
+    })
+    .fail((msg, err) => {
+      // Custom fail handler to suppress yargs error output
+      // Errors will be handled in the parseArguments catch block
+      if (err) throw err; // Rethrow actual errors
+      // For validation errors, throw a clean error object with the message
+      const error = new Error(msg);
+      error.name = 'YargsValidationError';
+      throw error;
+    })
+    .option('resume', {
+      type: 'string',
+      description: 'Resume from a previous session ID (when limit was reached)',
+      alias: 'r'
+    })
+    .option('only-prepare-command', {
+      type: 'boolean',
+      description: 'Only prepare and print the claude command without executing it',
+    })
+    .option('dry-run', {
+      type: 'boolean',
+      description: 'Prepare everything but do not execute Claude (alias for --only-prepare-command)',
+      alias: 'n'
+    })
+    .option('skip-tool-connection-check', {
+      type: 'boolean',
+      description: 'Skip tool connection check (useful in CI environments). Does NOT skip model validation.',
+      default: false
+    })
+    .option('skip-tool-check', {
+      type: 'boolean',
+      description: 'Alias for --skip-tool-connection-check (deprecated, use --skip-tool-connection-check instead)',
+      default: false,
+      hidden: true
+    })
+    .option('skip-claude-check', {
+      type: 'boolean',
+      description: 'Alias for --skip-tool-connection-check (deprecated)',
+      default: false,
+      hidden: true
+    })
+    .option('tool-connection-check', {
+      type: 'boolean',
+      description: 'Perform tool connection check (enabled by default, use --no-tool-connection-check to skip). Does NOT affect model validation.',
+      default: true,
+      hidden: true
+    })
+    .option('tool-check', {
+      type: 'boolean',
+      description: 'Alias for --tool-connection-check (deprecated)',
+      default: true,
+      hidden: true
+    })
+    .option('model', {
+      type: 'string',
+      description: 'Model to use (for claude: opus, sonnet, haiku, haiku-3-5, haiku-3; for opencode: grok, gpt4o; for codex: gpt5, gpt5-codex, o3; for agent: grok, grok-code, big-pickle)',
+      alias: 'm',
+      default: (currentParsedArgs) => {
+        // Dynamic default based on tool selection
+        if (currentParsedArgs?.tool === 'opencode') {
+          return 'grok-code-fast-1';
+        } else if (currentParsedArgs?.tool === 'codex') {
+          return 'gpt-5';
+        } else if (currentParsedArgs?.tool === 'agent') {
+          return 'grok-code';
+        }
+        return 'sonnet';
+      }
+    })
+    .option('auto-pull-request-creation', {
+      type: 'boolean',
+      description: 'Automatically create a draft pull request before running Claude',
+      default: true
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging for debugging',
+      alias: 'v',
+      default: false
+    })
+    .option('fork', {
+      type: 'boolean',
+      description: 'Fork the repository if you don\'t have write access',
+      alias: 'f',
+      default: false
+    })
+    .option('auto-fork', {
+      type: 'boolean',
+      description: 'Automatically fork public repositories without write access (fails for private repos)',
+      default: true
+    })
+    .option('attach-logs', {
+      type: 'boolean',
+      description: 'Upload the solution draft log file to the Pull Request on completion (⚠️ WARNING: May expose sensitive data)',
+      default: false
+    })
+    .option('auto-close-pull-request-on-fail', {
+      type: 'boolean',
+      description: 'Automatically close the pull request if execution fails',
+      default: false
+    })
+    .option('auto-continue', {
+      type: 'boolean',
+      description: 'Continue with existing PR when issue URL is provided (instead of creating new PR)',
+      default: true
+    })
+    .option('auto-continue-on-limit-reset', {
+      type: 'boolean',
+      description: 'Automatically continue when AI tool limit resets (calculates reset time and waits)',
+      default: false
+    })
+    .option('auto-resume-on-errors', {
+      type: 'boolean',
+      description: 'Automatically resume on network errors (503, etc.) with exponential backoff',
+      default: false
+    })
+    .option('auto-continue-only-on-new-comments', {
+      type: 'boolean',
+      description: 'Explicitly fail on absence of new comments in auto-continue or continue mode',
+      default: false
+    })
+    .option('auto-commit-uncommitted-changes', {
+      type: 'boolean',
+      description: 'Automatically commit and push uncommitted changes made by Claude (disabled by default)',
+      default: false
+    })
+    .option('auto-restart-on-uncommitted-changes', {
+      type: 'boolean',
+      description: 'Automatically restart when uncommitted changes are detected to allow the tool to handle them (default: true, use --no-auto-restart-on-uncommitted-changes to disable)',
+      default: true
+    })
+    .option('auto-restart-max-iterations', {
+      type: 'number',
+      description: 'Maximum number of auto-restart iterations when uncommitted changes are detected (default: 3)',
+      default: 3
+    })
+    .option('continue-only-on-feedback', {
+      type: 'boolean',
+      description: 'Only continue if feedback is detected (works only with pull request link or issue link with --auto-continue)',
+      default: false
+    })
+    .option('watch', {
+      type: 'boolean',
+      description: 'Monitor continuously for feedback and auto-restart when detected (stops when PR is merged)',
+      alias: 'w',
+      default: false
+    })
+    .option('watch-interval', {
+      type: 'number',
+      description: 'Interval in seconds for checking feedback in watch mode (default: 60)',
+      default: 60
+    })
+    .option('min-disk-space', {
+      type: 'number',
+      description: 'Minimum required disk space in MB (default: 500)',
+      default: 500
+    })
+    .option('log-dir', {
+      type: 'string',
+      description: 'Directory to save log files (defaults to current working directory)',
+      alias: 'l'
+    })
+    .option('think', {
+      type: 'string',
+      description: 'Thinking level: low (Think.), medium (Think hard.), high (Think harder.), max (Ultrathink.)',
+      choices: ['low', 'medium', 'high', 'max'],
+      default: undefined
+    })
+    .option('base-branch', {
+      type: 'string',
+      description: 'Target branch for the pull request (defaults to repository default branch)',
+      alias: 'b'
+    })
+    .option('sentry', {
+      type: 'boolean',
+      description: 'Enable Sentry error tracking and monitoring (use --no-sentry to disable)',
+      default: true
+    })
+    .option('auto-cleanup', {
+      type: 'boolean',
+      description: 'Automatically delete temporary working directory on completion (error, success, or CTRL+C). Default: true for private repos, false for public repos. Use explicit flag to override.',
+      default: undefined
+    })
+    .option('auto-merge-default-branch-to-pull-request-branch', {
+      type: 'boolean',
+      description: 'Automatically merge the default branch to the pull request branch when continuing work (only in continue mode)',
+      default: false
+    })
+    .option('allow-fork-divergence-resolution-using-force-push-with-lease', {
+      type: 'boolean',
+      description: 'Allow automatic force-push (--force-with-lease) when fork diverges from upstream (DANGEROUS: can overwrite fork history)',
+      default: false
+    })
+    .option('allow-to-push-to-contributors-pull-requests-as-maintainer', {
+      type: 'boolean',
+      description: 'When continuing a fork PR as a maintainer, attempt to push directly to the contributor\'s fork if "Allow edits by maintainers" is enabled. Requires --auto-fork to be enabled.',
+      default: false
+    })
+    .option('prefix-fork-name-with-owner-name', {
+      type: 'boolean',
+      description: 'Prefix fork name with original owner name (e.g., "owner-repo" instead of "repo"). Useful when forking repositories with same name from different owners.',
+      default: true
+    })
+    .option('tool', {
+      type: 'string',
+      description: 'AI tool to use for solving issues',
+      choices: ['claude', 'opencode', 'codex', 'agent'],
+      default: 'claude'
+    })
+    .option('interactive-mode', {
+      type: 'boolean',
+      description: '[EXPERIMENTAL] Post Claude output as PR comments in real-time. Only supported for --tool claude.',
+      default: false
+    })
+    .option('prompt-explore-sub-agent', {
+      type: 'boolean',
+      description: 'Encourage Claude to use Explore sub-agent for codebase exploration. Only supported for --tool claude.',
+      default: false
+    })
+    .parserConfiguration({
+      'boolean-negation': true
+    })
+    // Use yargs built-in strict mode to reject unrecognized options
+    // This prevents issues like #453 and #482 where unknown options are silently ignored
+    .strict()
+    .help('h')
+    .alias('h', 'help');
+};
+
+// Parse command line arguments - now needs yargs and hideBin passed in
+export const parseArguments = async (yargs, hideBin) => {
+  const rawArgs = hideBin(process.argv);
+  // Use .parse() instead of .argv to ensure .strict() mode works correctly
+  // When you call yargs(args) and use .argv, strict mode doesn't trigger
+  // See: https://github.com/yargs/yargs/issues - .strict() only works with .parse()
+
+  let argv;
+  try {
+    // Suppress stderr output from yargs during parsing to prevent validation errors from appearing
+    // This prevents "YError: Not enough arguments" from polluting stderr (issue #583)
+    // Save the original stderr.write
+    const originalStderrWrite = process.stderr.write;
+    const stderrBuffer = [];
+
+    // Temporarily override stderr.write to capture output
+    process.stderr.write = function(chunk, encoding, callback) {
+      stderrBuffer.push(chunk.toString());
+      // Call the callback if provided (for compatibility)
+      if (typeof encoding === 'function') {
+        encoding();
+      } else if (typeof callback === 'function') {
+        callback();
+      }
+      return true;
+    };
+
+    try {
+      argv = await createYargsConfig(yargs()).parse(rawArgs);
+    } finally {
+      // Always restore stderr.write
+      process.stderr.write = originalStderrWrite;
+
+      // In verbose mode, show what was captured from stderr (for debugging)
+      if (global.verboseMode && stderrBuffer.length > 0) {
+        const captured = stderrBuffer.join('');
+        if (captured.trim()) {
+          console.error('[Suppressed yargs stderr]:', captured);
+        }
+      }
+    }
+  } catch (error) {
+    // Yargs throws errors for validation issues
+    // If the error is about unknown arguments (strict mode), re-throw it
+    if (error.message && error.message.includes('Unknown arguments')) {
+      throw error;
+    }
+    // For other validation errors, show a warning in verbose mode
+    if (error.message && global.verboseMode) {
+      console.error('Yargs parsing warning:', error.message);
+    }
+    // Try to get the argv even with the error
+    argv = error.argv || {};
+  }
+
+  // Post-processing: Fix model default for opencode and codex tools
+  // Yargs doesn't properly handle dynamic defaults based on other arguments,
+  // so we need to handle this manually after parsing
+  const modelExplicitlyProvided = rawArgs.includes('--model') || rawArgs.includes('-m');
+
+  // Normalize alias flags: legacy --skip-tool-check and --skip-claude-check behave like --skip-tool-connection-check
+  if (argv) {
+    // Support deprecated flags
+    if (argv.skipToolCheck || argv.skipClaudeCheck) {
+      argv.skipToolConnectionCheck = true;
+    }
+    // Support negated deprecated flag: --no-tool-check becomes --no-tool-connection-check
+    if (argv.toolCheck === false) {
+      argv.toolConnectionCheck = false;
+    }
+  }
+
+  if (argv.tool === 'opencode' && !modelExplicitlyProvided) {
+    // User did not explicitly provide --model, so use the correct default for opencode
+    argv.model = 'grok-code-fast-1';
+  } else if (argv.tool === 'codex' && !modelExplicitlyProvided) {
+    // User did not explicitly provide --model, so use the correct default for codex
+    argv.model = 'gpt-5';
+  } else if (argv.tool === 'agent' && !modelExplicitlyProvided) {
+    // User did not explicitly provide --model, so use the correct default for agent
+    argv.model = 'grok-code';
+  }
+
+  return argv;
+};

package/src/solve.error-handlers.lib.mjs

@@ -0,0 +1,256 @@
+/**
+ * Error handling utilities for solve.mjs
+ */
+
+// Import exit handler
+import { safeExit } from './exit-handler.lib.mjs';
+
+// Import Sentry integration
+import { reportError } from './sentry.lib.mjs';
+
+// Import GitHub issue creator
+import { handleErrorWithIssueCreation } from './github-issue-creator.lib.mjs';
+
+/**
+ * Handles log attachment and PR closing on failure
+ */
+export const handleFailure = async (options) => {
+  const {
+    error,
+    errorType,
+    shouldAttachLogs,
+    argv,
+    global,
+    owner,
+    repo,
+    log,
+    getLogFile,
+    attachLogToGitHub,
+    cleanErrorMessage,
+    sanitizeLogContent,
+    $
+  } = options;
+
+  // Offer to create GitHub issue for the error
+  try {
+    await handleErrorWithIssueCreation({
+      error,
+      errorType,
+      logFile: getLogFile(),
+      context: {
+        owner: global.owner || owner,
+        repo: global.repo || repo,
+        prNumber: global.createdPR?.number,
+        errorType
+      },
+      skipPrompt: !process.stdin.isTTY || argv.noIssueCreation
+    });
+  } catch (issueError) {
+    reportError(issueError, {
+      context: 'automatic_issue_creation',
+      operation: 'handle_error_with_issue_creation'
+    });
+    await log(`⚠️  Could not create issue: ${issueError.message}`, { level: 'warning' });
+  }
+
+  // If --attach-logs is enabled, try to attach failure logs
+  if (shouldAttachLogs && getLogFile() && global.createdPR && global.createdPR.number) {
+    await log('\n📄 Attempting to attach failure logs...');
+    try {
+      const logUploadSuccess = await attachLogToGitHub({
+        logFile: getLogFile(),
+        targetType: 'pr',
+        targetNumber: global.createdPR.number,
+        owner: global.owner || owner,
+        repo: global.repo || repo,
+        $,
+        log,
+        sanitizeLogContent,
+        verbose: argv.verbose,
+        errorMessage: cleanErrorMessage(error)
+      });
+      if (logUploadSuccess) {
+        await log('📎 Failure log attached to Pull Request');
+      }
+    } catch (attachError) {
+      reportError(attachError, {
+        context: 'attach_failure_log',
+        prNumber: global.createdPR?.number,
+        errorType,
+        operation: 'attach_log_to_pr'
+      });
+      await log(`⚠️  Could not attach failure log: ${attachError.message}`, { level: 'warning' });
+    }
+  }
+
+  // If --auto-close-pull-request-on-fail is enabled, close the PR
+  if (argv.autoClosePullRequestOnFail && global.createdPR && global.createdPR.number) {
+    await log('\n🔒 Auto-closing pull request due to failure...');
+    try {
+      const closeMessage = errorType === 'uncaughtException'
+        ? 'Auto-closed due to uncaught exception. Logs have been attached for debugging.'
+        : errorType === 'unhandledRejection'
+        ? 'Auto-closed due to unhandled rejection. Logs have been attached for debugging.'
+        : 'Auto-closed due to execution failure. Logs have been attached for debugging.';
+
+      const result = await $`gh pr close ${global.createdPR.number} --repo ${global.owner || owner}/${global.repo || repo} --comment ${closeMessage}`;
+      if (result.exitCode === 0) {
+        await log('✅ Pull request closed successfully');
+      }
+    } catch (closeError) {
+      reportError(closeError, {
+        context: 'close_pr_on_failure',
+        prNumber: global.createdPR?.number,
+        owner,
+        repo,
+        operation: 'close_pull_request'
+      });
+      await log(`⚠️  Could not close pull request: ${closeError.message}`, { level: 'warning' });
+    }
+  }
+};
+
+/**
+ * Creates an uncaught exception handler
+ */
+export const createUncaughtExceptionHandler = (options) => {
+  const {
+    log,
+    cleanErrorMessage,
+    absoluteLogPath,
+    shouldAttachLogs,
+    argv,
+    global,
+    owner,
+    repo,
+    getLogFile,
+    attachLogToGitHub,
+    sanitizeLogContent,
+    $
+  } = options;
+
+  return async (error) => {
+    await log(`\n❌ Uncaught Exception: ${cleanErrorMessage(error)}`, { level: 'error' });
+    await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
+
+    await handleFailure({
+      error,
+      errorType: 'uncaughtException',
+      shouldAttachLogs,
+      argv,
+      global,
+      owner,
+      repo,
+      log,
+      getLogFile,
+      attachLogToGitHub,
+      cleanErrorMessage,
+      sanitizeLogContent,
+      $
+    });
+
+    await safeExit(1, 'Error occurred');
+  };
+};
+
+/**
+ * Creates an unhandled rejection handler
+ */
+export const createUnhandledRejectionHandler = (options) => {
+  const {
+    log,
+    cleanErrorMessage,
+    absoluteLogPath,
+    shouldAttachLogs,
+    argv,
+    global,
+    owner,
+    repo,
+    getLogFile,
+    attachLogToGitHub,
+    sanitizeLogContent,
+    $
+  } = options;
+
+  return async (reason) => {
+    await log(`\n❌ Unhandled Rejection: ${cleanErrorMessage(reason)}`, { level: 'error' });
+    await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
+
+    await handleFailure({
+      error: reason,
+      errorType: 'unhandledRejection',
+      shouldAttachLogs,
+      argv,
+      global,
+      owner,
+      repo,
+      log,
+      getLogFile,
+      attachLogToGitHub,
+      cleanErrorMessage,
+      sanitizeLogContent,
+      $
+    });
+
+    await safeExit(1, 'Error occurred');
+  };
+};
+
+/**
+ * Handles execution errors in the main catch block
+ */
+export const handleMainExecutionError = async (options) => {
+  const {
+    error,
+    log,
+    cleanErrorMessage,
+    absoluteLogPath,
+    shouldAttachLogs,
+    argv,
+    global,
+    owner,
+    repo,
+    getLogFile,
+    attachLogToGitHub,
+    sanitizeLogContent,
+    $
+  } = options;
+
+  // Special handling for authentication errors
+  if (error.isAuthError) {
+    await log('\n❌ AUTHENTICATION ERROR', { level: 'error' });
+    await log('', { level: 'error' });
+    await log('   The AI tool authentication has failed.', { level: 'error' });
+    await log('   This error cannot be resolved by retrying.', { level: 'error' });
+    await log('', { level: 'error' });
+    await log(`   Error: ${cleanErrorMessage(error)}`, { level: 'error' });
+    await log('', { level: 'error' });
+    await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
+
+    // Don't try to attach logs or create issues for auth errors
+    await safeExit(1, 'Authentication error');
+    return;
+  }
+
+  await log('Error executing command:', cleanErrorMessage(error));
+  await log(`Stack trace: ${error.stack}`, { verbose: true });
+  await log(`   📁 Full log file: ${absoluteLogPath}`, { level: 'error' });
+
+  await handleFailure({
+    error,
+    errorType: 'execution',
+    shouldAttachLogs,
+    argv,
+    global,
+    owner,
+    repo,
+    log,
+    getLogFile,
+    attachLogToGitHub,
+    cleanErrorMessage,
+    sanitizeLogContent,
+    $
+  });
+
+  await safeExit(1, 'Error occurred');
+};