@link-assistant/hive-mind 1.59.6 → 1.60.0

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'],
+  });