@link-assistant/hive-mind 1.59.7 → 1.61.0

package/src/reviewers-hive.mjs

@@ -7,7 +7,7 @@ const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text(
 const { $: __rawDollar$ } = await use('command-stream');
 const { wrapDollarWithGhRetry } = await import('./github-rate-limit.lib.mjs');
 const $ = wrapDollarWithGhRetry(__rawDollar$);
-const yargs = (await use('yargs@latest')).default;
+const { getLinoYargsFactory, hideBin, parseCliArgumentsWithLino } = await import('./cli-arguments.lib.mjs');
 const path = (await use('path')).default;
 const fs = (await use('fs')).promises;
 
@@ -46,97 +46,113 @@ const log = async (message, options = {}) => {
 };
 
 // Configure command line arguments
-const argv = yargs(process.argv.slice(2))
-  .usage('Usage: $0 <github-url> [options]')
-  .positional('github-url', {
-    type: 'string',
-    description: 'GitHub organization, repository, or user URL to monitor for pull requests',
-  })
-  .option('review-label', {
-    type: 'string',
-    description: 'GitHub label to identify PRs needing review',
-    default: 'needs-review',
-    alias: 'l',
-  })
-  .option('all-prs', {
-    type: 'boolean',
-    description: 'Review all open pull requests regardless of labels',
-    default: false,
-    alias: 'a',
-  })
-  .option('skip-draft', {
-    type: 'boolean',
-    description: 'Skip draft pull requests',
-    default: true,
-    alias: 'd',
-  })
-  .option('skip-approved', {
-    type: 'boolean',
-    description: 'Skip pull requests that already have approvals',
-    default: true,
-  })
-  .option('concurrency', {
-    type: 'number',
-    description: 'Number of concurrent review.mjs instances',
-    default: 2,
-    alias: 'c',
-  })
-  .option('reviews-per-pr', {
-    type: 'number',
-    description: 'Number of reviews to generate per PR (for diverse perspectives)',
-    default: 1,
-    alias: 'r',
-  })
-  .option('model', {
-    type: 'string',
-    description: 'Model to use for review.mjs (opus or sonnet)',
-    alias: 'm',
-    default: 'opus',
-    choices: ['opus', 'sonnet'],
-  })
-  .option('focus', {
-    type: 'string',
-    description: 'Focus areas for reviews (security, performance, logic, style, tests, all)',
-    default: 'all',
-    alias: 'f',
-  })
-  .option('auto-approve', {
-    type: 'boolean',
-    description: 'Auto-approve PRs that pass review criteria',
-    default: false,
-  })
-  .option('interval', {
-    type: 'number',
-    description: 'Polling interval in seconds',
-    default: 300, // 5 minutes
-    alias: 'i',
-  })
-  .option('max-prs', {
-    type: 'number',
-    description: 'Maximum number of PRs to process (0 = unlimited)',
-    default: 0,
-  })
-  .option('dry-run', {
-    type: 'boolean',
-    description: 'List PRs that would be reviewed without actually reviewing them',
-    default: false,
-  })
-  .option('verbose', {
-    type: 'boolean',
-    description: 'Enable verbose logging',
-    alias: 'v',
-    default: false,
-  })
-  .option('once', {
-    type: 'boolean',
-    description: 'Run once and exit instead of continuous monitoring',
-    default: false,
-  })
-  .demandCommand(1, 'GitHub URL is required')
-  .help('h')
-  .alias('h', 'help').argv;
-
-const githubUrl = argv['github-url'] || argv._[0];
+const createReviewersHiveYargsConfig = yargsInstance =>
+  yargsInstance
+    .usage('Usage: $0 <github-url> [options]')
+    .command('$0 <github-url>', 'Monitor pull requests for review', yargs =>
+      yargs.positional('github-url', {
+        type: 'string',
+        description: 'GitHub organization, repository, or user URL to monitor for pull requests',
+      })
+    )
+    .option('review-label', {
+      type: 'string',
+      description: 'GitHub label to identify PRs needing review',
+      default: 'needs-review',
+      alias: 'l',
+    })
+    .option('all-prs', {
+      type: 'boolean',
+      description: 'Review all open pull requests regardless of labels',
+      default: false,
+      alias: 'a',
+    })
+    .option('skip-draft', {
+      type: 'boolean',
+      description: 'Skip draft pull requests',
+      default: true,
+      alias: 'd',
+    })
+    .option('skip-approved', {
+      type: 'boolean',
+      description: 'Skip pull requests that already have approvals',
+      default: true,
+    })
+    .option('concurrency', {
+      type: 'number',
+      description: 'Number of concurrent review.mjs instances',
+      default: 2,
+      alias: 'c',
+    })
+    .option('reviews-per-pr', {
+      type: 'number',
+      description: 'Number of reviews to generate per PR (for diverse perspectives)',
+      default: 1,
+      alias: 'r',
+    })
+    .option('model', {
+      type: 'string',
+      description: 'Model to use for review.mjs (opus or sonnet)',
+      alias: 'm',
+      default: 'opus',
+      choices: ['opus', 'sonnet'],
+    })
+    .option('focus', {
+      type: 'string',
+      description: 'Focus areas for reviews (security, performance, logic, style, tests, all)',
+      default: 'all',
+      alias: 'f',
+    })
+    .option('auto-approve', {
+      type: 'boolean',
+      description: 'Auto-approve PRs that pass review criteria',
+      default: false,
+    })
+    .option('interval', {
+      type: 'number',
+      description: 'Polling interval in seconds',
+      default: 300, // 5 minutes
+      alias: 'i',
+    })
+    .option('max-prs', {
+      type: 'number',
+      description: 'Maximum number of PRs to process (0 = unlimited)',
+      default: 0,
+    })
+    .option('dry-run', {
+      type: 'boolean',
+      description: 'List PRs that would be reviewed without actually reviewing them',
+      default: false,
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging',
+      alias: 'v',
+      default: false,
+    })
+    .option('once', {
+      type: 'boolean',
+      description: 'Run once and exit instead of continuous monitoring',
+      default: false,
+    })
+    .demandCommand(1, 'GitHub URL is required')
+    .help('h')
+    .alias('h', 'help');
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  const helpYargs = createReviewersHiveYargsConfig(getLinoYargsFactory()(hideBin(process.argv)));
+  helpYargs.showHelp();
+  process.exit(0);
+}
+
+const argv = parseCliArgumentsWithLino({
+  argv: process.argv,
+  commandName: 'reviewers-hive',
+  createYargsConfig: createReviewersHiveYargsConfig,
+  positionalAliases: ['github-url'],
+});
+
+const githubUrl = argv['github-url'] || argv.githubUrl || argv._[0];
 
 // Set global verbose mode
 global.verboseMode = argv.verbose;

package/src/solve.config.lib.mjs

@@ -10,23 +10,13 @@
 import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.lib.mjs';
 import { defaultModels, buildModelOptionDescription, resolveDefaultFallbackModel, resolveRuntimeDefaultModel } from './models/index.mjs';
 import { validateBranchName } from './solve.branch.lib.mjs';
-import { resolveYargsFactory } from './yargs-factory.lib.mjs';
+import { getLinoYargsFactory, hideBin, parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 
 // Re-export for use by telegram-bot.mjs (avoids extra import lines there)
 export { detectMalformedFlags };
 
 // 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 = resolveYargsFactory(yargsModule);
-  const helpersModule = await use('yargs@17.7.2/helpers');
-  // Node 24 CJS/ESM interop may return the whole module object instead of named exports directly
-  const helpers = helpersModule.default || helpersModule;
-  const hideBin = helpers.hideBin || (argv => argv.slice(2));
-
-  return { yargs, hideBin };
-};
+export const initializeConfig = async () => ({ yargs: getLinoYargsFactory(), hideBin });
 
 // Solve option definitions as a plain data structure.
 // This is the single source of truth for all solve command options.
@@ -582,8 +572,8 @@ export const createYargsConfig = yargsInstance => {
 };
 
 // Parse command line arguments - now needs yargs and hideBin passed in
-export const parseArguments = async (yargs, hideBin) => {
-  const rawArgs = hideBin(process.argv);
+export const parseArguments = async (yargs = getLinoYargsFactory(), hideBinFn = hideBin) => {
+  const rawArgs = hideBinFn(process.argv);
 
   // Issue #1092: Detect malformed flag patterns BEFORE yargs parsing
   // This catches cases like "-- model" which yargs silently treats as positional arguments
@@ -621,7 +611,12 @@ export const parseArguments = async (yargs, hideBin) => {
 
     try {
       yargsInstance = createYargsConfig(yargs());
-      argv = await yargsInstance.parse(rawArgs);
+      argv = parseCliArgumentsWithLino({
+        argv: process.argv,
+        commandName: 'solve',
+        createYargsConfig,
+        positionalAliases: ['issue-url'],
+      });
     } finally {
       // Always restore stderr.write
       process.stderr.write = originalStderrWrite;

package/src/start-screen.mjs

@@ -3,6 +3,7 @@
 
 import { exec } from 'child_process';
 import { promisify } from 'util';
+import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
 
 const execAsync = promisify(exec);
 
@@ -10,6 +11,72 @@ const execAsync = promisify(exec);
 // This ensures consistent URL validation across all commands (hive, solve, start-screen)
 const { parseGitHubUrl } = await import('./github.lib.mjs');
 
+const START_SCREEN_USAGE = ['Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]', '', 'Options:', '  --auto-terminate    Session terminates after command completes (old behavior)', '                      By default, session stays alive for review and reattachment', '', 'Examples:', '  start-screen solve https://github.com/user/repo/issues/123 --dry-run', '  start-screen --auto-terminate solve https://github.com/user/repo/issues/456', '  start-screen hive https://github.com/user/repo --flag value'];
+
+const printUsage = (log = console.error) => {
+  for (const line of START_SCREEN_USAGE) {
+    log(line);
+  }
+};
+
+const createStartScreenYargsConfig = yargsInstance =>
+  yargsInstance
+    .usage(START_SCREEN_USAGE[0])
+    .command('$0 <command> <github-url> [additional-args..]', 'Launch solve or hive in a GNU screen session', yargs =>
+      yargs
+        .positional('command', {
+          type: 'string',
+          description: 'Command to run',
+        })
+        .positional('github-url', {
+          type: 'string',
+          description: 'GitHub repository or issue URL',
+        })
+        .positional('additional-args', {
+          array: true,
+          type: 'string',
+          description: 'Arguments to pass through to the command',
+        })
+    )
+    .option('auto-terminate', {
+      type: 'boolean',
+      description: 'Session terminates after command completes',
+      default: false,
+    })
+    .option('help', {
+      type: 'boolean',
+      description: 'Show help',
+      alias: 'h',
+      default: false,
+    })
+    .parserConfiguration({
+      'boolean-negation': true,
+      'unknown-options-as-args': true,
+    })
+    .help(false)
+    .version(false)
+    .strict(false);
+
+const parseStartScreenArgs = args => {
+  const help = args.includes('--help') || args.includes('-h');
+  const parsed = parseCliArgumentsWithLino({
+    argv: args.filter(arg => arg !== '--help' && arg !== '-h'),
+    commandName: 'start-screen',
+    createYargsConfig: createStartScreenYargsConfig,
+    positionalAliases: ['command', 'github-url', 'additional-args'],
+    lenv: { enabled: false },
+    getenv: { enabled: false },
+  });
+  const additionalArgs = parsed.additionalArgs || parsed['additional-args'] || [];
+  return {
+    autoTerminate: parsed.autoTerminate === true || parsed['auto-terminate'] === true,
+    help,
+    command: parsed.command,
+    githubUrl: parsed.githubUrl || parsed['github-url'],
+    commandArgs: Array.isArray(additionalArgs) ? additionalArgs : [additionalArgs],
+  };
+};
+
 /**
  * Generate a screen session name based on the command and GitHub URL
  * @param {string} command - Either 'solve' or 'hive'
@@ -221,23 +288,18 @@ async function createOrEnterScreen(sessionName, command, args, autoTerminate = f
 async function main() {
   const args = process.argv.slice(2);
 
+  if (args.includes('--help') || args.includes('-h')) {
+    printUsage(console.log);
+    process.exit(0);
+  }
+
   if (args.length < 2) {
-    console.error('Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]');
-    console.error('');
-    console.error('Options:');
-    console.error('  --auto-terminate    Session terminates after command completes (old behavior)');
-    console.error('                      By default, session stays alive for review and reattachment');
-    console.error('');
-    console.error('Examples:');
-    console.error('  start-screen solve https://github.com/user/repo/issues/123 --dry-run');
-    console.error('  start-screen --auto-terminate solve https://github.com/user/repo/issues/456');
-    console.error('  start-screen hive https://github.com/user/repo --flag value');
+    printUsage(console.error);
     process.exit(1);
   }
 
   // Check for --auto-terminate flag at the beginning
   // Also validate that first arg is not an unrecognized option with em-dash or other invalid dash
-  let autoTerminate = false;
   let argsOffset = 0;
 
   // Check for various dash characters in first argument (em-dash \u2014, en-dash \u2013, etc.)
@@ -249,7 +311,6 @@ async function main() {
   }
 
   if (args[0] === '--auto-terminate') {
-    autoTerminate = true;
     argsOffset = 1;
 
     if (args.length < 3) {
@@ -277,9 +338,7 @@ async function main() {
     }
   }
 
-  const command = args[argsOffset];
-  const githubUrl = args[argsOffset + 1];
-  const commandArgs = args.slice(argsOffset + 2);
+  const { autoTerminate, command, githubUrl, commandArgs } = parseStartScreenArgs(args);
 
   // Validate command
   if (command !== 'solve' && command !== 'hive') {

package/src/task.agent-command.lib.mjs

@@ -0,0 +1,61 @@
+import path from 'path';
+import { constants as fsConstants, promises as fs } from 'fs';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+function startAgentExecutableName() {
+  return process.platform === 'win32' ? 'start-agent.cmd' : 'start-agent';
+}
+
+async function canExecute(filePath) {
+  try {
+    await fs.access(filePath, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getBundledStartAgentCandidate() {
+  try {
+    const entryPath = require.resolve('agent-commander');
+    return path.join(path.dirname(path.dirname(entryPath)), 'bin', 'start-agent.mjs');
+  } catch {
+    return null;
+  }
+}
+
+export async function resolveStartAgentCommand(options = {}) {
+  const { cwd = process.cwd(), runCommand } = options;
+  const candidates = [getBundledStartAgentCandidate(), path.join(cwd, 'node_modules', '.bin', startAgentExecutableName())].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (await canExecute(candidate)) return candidate;
+  }
+
+  if (!runCommand) return null;
+
+  const lookupCommand = process.platform === 'win32' ? 'where' : 'which';
+  const result = await runCommand(lookupCommand, ['start-agent']);
+  if (result.code !== 0) return null;
+
+  return (
+    (result.stdout || '')
+      .split(/\r?\n/)
+      .map(line => line.trim())
+      .find(Boolean) || null
+  );
+}
+
+export function buildStartAgentArgs(options) {
+  const { tool, workingDirectory, prompt, systemPrompt, model, isolation, screenName, verbose } = options;
+  const args = ['--tool', tool, '--working-directory', workingDirectory, '--prompt', prompt, '--system-prompt', systemPrompt, '--model', model, '--isolation', isolation, '--read-only'];
+
+  if (isolation === 'screen' && screenName) {
+    args.push('--screen-name', screenName);
+  }
+  if (verbose) args.push('--verbose');
+
+  return args;
+}

package/src/task.config.lib.mjs

@@ -0,0 +1,122 @@
+import { buildModelOptionDescription, defaultModels } from './models/index.mjs';
+import { parseCliArgumentsWithLino } from './cli-arguments.lib.mjs';
+
+export const TASK_TOOL_CHOICES = ['claude', 'codex', 'opencode', 'agent'];
+
+export function getDefaultTaskModel(tool) {
+  return defaultModels[tool] || defaultModels.claude;
+}
+
+export const createYargsConfig = yargsInstance =>
+  yargsInstance
+    .usage('Usage: task.mjs <task-description> [options]')
+    .command('$0 <task-input>', 'Clarify, decompose, or split a task', yargs => {
+      yargs.positional('task-input', {
+        type: 'string',
+        description: 'GitHub issue URL for --split, or a task description for clarify/decompose mode',
+      });
+    })
+    .option('clarify', {
+      type: 'boolean',
+      description: 'Enable clarification mode',
+      default: true,
+    })
+    .option('decompose', {
+      type: 'boolean',
+      description: 'Enable decomposition mode',
+      default: true,
+    })
+    .option('only-clarify', {
+      type: 'boolean',
+      description: 'Only run clarification mode',
+      default: false,
+    })
+    .option('only-decompose', {
+      type: 'boolean',
+      description: 'Only run decomposition mode',
+      default: false,
+    })
+    .option('split', {
+      type: 'boolean',
+      description: 'Split a GitHub issue into smaller GitHub issues',
+      default: false,
+    })
+    .option('split-count', {
+      type: 'number',
+      description: 'Number of issues to split into',
+      default: 2,
+    })
+    .option('tool', {
+      type: 'string',
+      description: 'AI tool to use through agent-commander read-only mode',
+      choices: TASK_TOOL_CHOICES,
+      default: 'claude',
+    })
+    .option('model', {
+      type: 'string',
+      description: buildModelOptionDescription(),
+      alias: 'm',
+    })
+    .option('isolation', {
+      type: 'string',
+      description: 'agent-commander isolation mode',
+      choices: ['screen', 'none', 'docker'],
+      default: 'screen',
+    })
+    .option('screen-name', {
+      type: 'string',
+      description: 'Screen session name when --isolation screen is used',
+    })
+    .option('dry-run', {
+      type: 'boolean',
+      description: 'Print planned split issues without creating or linking GitHub issues',
+      default: false,
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging',
+      alias: 'v',
+      default: false,
+    })
+    .option('output-format', {
+      type: 'string',
+      description: 'Output format',
+      alias: 'o',
+      choices: ['text', 'json'],
+      default: 'text',
+    })
+    .check(argv => {
+      if (!argv['task-input'] && !argv._[0]) {
+        throw new Error('Please provide a GitHub issue URL or task description');
+      }
+      if (argv['only-clarify'] && argv['only-decompose']) {
+        throw new Error('Cannot use both --only-clarify and --only-decompose at the same time');
+      }
+      if (argv.split && (argv['only-clarify'] || argv['only-decompose'])) {
+        throw new Error('Cannot use --split with --only-clarify or --only-decompose');
+      }
+      if (argv.split && argv['split-count'] < 2) {
+        throw new Error('--split-count must be at least 2');
+      }
+      if (argv['only-clarify']) argv.decompose = false;
+      if (argv['only-decompose']) argv.clarify = false;
+      if (argv.split) {
+        argv.clarify = false;
+        argv.decompose = false;
+      }
+      return true;
+    })
+    .parserConfiguration({
+      'boolean-negation': true,
+    })
+    .strict()
+    .help('h')
+    .alias('h', 'help');
+
+export const parseTaskArguments = (argv = process.argv) =>
+  parseCliArgumentsWithLino({
+    argv,
+    commandName: 'task',
+    createYargsConfig,
+    positionalAliases: ['task-input'],
+  });