@link-assistant/hive-mind 1.59.7 → 1.61.0

package/src/task.mjs

@@ -1,13 +1,20 @@
 #!/usr/bin/env node
 
-// Early exit paths - handle these before loading all modules to speed up testing
+import crypto from 'crypto';
+import path from 'path';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import { buildStartAgentArgs, resolveStartAgentCommand } from './task.agent-command.lib.mjs';
+import { getDefaultTaskModel, parseTaskArguments } from './task.config.lib.mjs';
+import { validateModelName } from './models/index.mjs';
+import { appendOrReplaceParentSplitSection, buildAddSubIssueApiArgs, buildIssueRestIdApiArgs, buildTaskSplitPrompt, buildTaskSplitSystemPrompt, extractTaskSplitJson, formatChildIssueBody, normalizeSplitTasks, parseCreatedIssueUrl, parseTaskIssueUrl } from './task.split.lib.mjs';
+
 const earlyArgs = process.argv.slice(2);
 
 if (earlyArgs.includes('--version')) {
   const { getVersion } = await import('./version.lib.mjs');
   try {
-    const version = await getVersion();
-    console.log(version);
+    console.log(await getVersion());
   } catch {
     console.error('Error: Unable to determine version');
     process.exit(1);
@@ -15,8 +22,7 @@ if (earlyArgs.includes('--version')) {
   process.exit(0);
 }
 
-if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
-  // Show help and exit
+if (earlyArgs.length === 0 || earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
   console.log('Usage: task.mjs <task-description> [options]');
   console.log('\nOptions:');
   console.log('  --version          Show version number');
@@ -25,283 +31,262 @@ if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
   console.log('  --decompose        Enable decomposition mode [default: true]');
   console.log('  --only-clarify     Only run clarification mode');
   console.log('  --only-decompose   Only run decomposition mode');
-  console.log('  --model, -m        Model to use (opus, sonnet, or full model ID) [default: sonnet]');
+  console.log('  --split            Split a GitHub issue into smaller issues');
+  console.log('  --split-count      Number of issues to split into [default: 2]');
+  console.log('  --tool             AI tool for agent-commander read-only mode (claude, codex, opencode, agent) [default: claude]');
+  console.log('  --model, -m        Model to use');
+  console.log('  --isolation        agent-commander isolation mode [default: screen]');
+  console.log('  --dry-run          Print split output without creating GitHub issues');
   console.log('  --verbose, -v      Enable verbose logging');
   console.log('  --output-format    Output format (text or json) [default: text]');
-  process.exit(0);
+  process.exit(earlyArgs.length === 0 ? 1 : 0);
 }
 
-// Use use-m to dynamically import modules for cross-runtime compatibility
-const { use } = eval(await (await fetch('https://unpkg.com/use-m/use.js')).text());
-
-const yargs = (await use('yargs@latest')).default;
-const path = (await use('path')).default;
-const fs = (await use('fs')).promises;
-const { spawn } = (await use('child_process')).default;
-
-// Import Claude execution functions
-import { mapModelToId } from './claude.lib.mjs';
-import { claudeModels, defaultModels, buildModelOptionDescription } from './models/index.mjs';
-
-// Global log file reference
-let logFile = null;
-
-// Helper function to log to both console and file
-const log = async (message, options = {}) => {
-  const { level = 'info', verbose = false } = options;
-
-  // Skip verbose logs unless --verbose is enabled
-  if (verbose && !global.verboseMode) {
-    return;
-  }
-
-  // Write to file if log file is set
-  if (logFile) {
-    const logMessage = `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}`;
-    await fs.appendFile(logFile, logMessage + '\n').catch(() => {});
-  }
-
-  // Write to console based on level
-  switch (level) {
-    case 'error':
-      console.error(message);
-      break;
-    case 'warning':
-    case 'warn':
-      console.warn(message);
-      break;
-    case 'info':
-    default:
-      console.log(message);
-      break;
-  }
-};
-
-// Configure command line arguments - task description as positional argument
-// Use yargs().parse(args) instead of yargs(args).argv to ensure .strict() mode works
-const argv = yargs()
-  .usage('Usage: $0 <task-description> [options]')
-  .positional('task-description', {
-    type: 'string',
-    description: 'The task to clarify and decompose',
-  })
-  .option('clarify', {
-    type: 'boolean',
-    description: 'Enable clarification mode (asks clarifying questions about the task)',
-    default: true,
-  })
-  .option('decompose', {
-    type: 'boolean',
-    description: 'Enable decomposition mode (breaks down the task into subtasks)',
-    default: true,
-  })
-  .option('only-clarify', {
-    type: 'boolean',
-    description: 'Only run clarification mode, skip decomposition',
-    default: false,
-  })
-  .option('only-decompose', {
-    type: 'boolean',
-    description: 'Only run decomposition mode, skip clarification',
-    default: false,
-  })
-  .option('model', {
-    type: 'string',
-    description: buildModelOptionDescription(),
-    alias: 'm',
-    default: defaultModels.claude,
-    choices: Object.keys(claudeModels),
-  })
-  .option('verbose', {
-    type: 'boolean',
-    description: 'Enable verbose logging for debugging',
-    alias: 'v',
-    default: false,
-  })
-  .option('output-format', {
-    type: 'string',
-    description: 'Output format (text or json)',
-    alias: 'o',
-    default: 'text',
-    choices: ['text', 'json'],
-  })
-  .option('execute-tool-with-bun', {
-    type: 'boolean',
-    description: 'Execute the AI tool using bunx (experimental, may improve speed and memory usage)',
-    default: false,
-  })
-  .check(argv => {
-    if (!argv['task-description'] && !argv._[0]) {
-      throw new Error('Please provide a task description');
-    }
-
-    // Handle mutual exclusivity of only-clarify and only-decompose
-    if (argv['only-clarify'] && argv['only-decompose']) {
-      throw new Error('Cannot use both --only-clarify and --only-decompose at the same time');
-    }
-
-    // If only-clarify is set, disable decompose
-    if (argv['only-clarify']) {
-      argv.decompose = false;
-    }
-
-    // If only-decompose is set, disable clarify
-    if (argv['only-decompose']) {
-      argv.clarify = false;
-    }
-
-    return true;
-  })
-  .parserConfiguration({
-    'boolean-negation': true,
-  })
-  .help()
-  .alias('h', 'help')
-  // Use yargs built-in strict mode to reject unrecognized options
-  // This prevents issues like #453 and #482 where unknown options are silently ignored
-  .strict()
-  .parse(process.argv.slice(2));
-
-const taskDescription = argv['task-description'] || argv._[0];
+let argv;
+try {
+  argv = parseTaskArguments(process.argv);
+} catch (error) {
+  console.error(error.message || String(error));
+  process.exit(1);
+}
 
-// Set global verbose mode for log function
-global.verboseMode = argv.verbose;
+const taskInput = argv['task-input'] || argv.taskInput || argv._[0];
+const selectedModel = argv.model || getDefaultTaskModel(argv.tool);
+const modelValidation = validateModelName(selectedModel, argv.tool);
+if (!modelValidation.valid) {
+  console.error(modelValidation.message);
+  process.exit(1);
+}
 
-// Create permanent log file immediately with timestamp
 const scriptDir = path.dirname(process.argv[1]);
 const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-logFile = path.join(scriptDir, `task-${timestamp}.log`);
+const logFile = path.join(scriptDir, `task-${timestamp}.log`);
 
-// Create the log file immediately
-await fs.writeFile(logFile, `# Task.mjs Log - ${new Date().toISOString()}\n\n`);
-await log(`📁 Log file: ${logFile}`);
-await log('   (All output will be logged here)');
+async function log(message, options = {}) {
+  const { level = 'info', verbose = false } = options;
+  if (verbose && !argv.verbose) return;
+  await fs.appendFile(logFile, `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}\n`).catch(() => {});
+  if (level === 'error') console.error(message);
+  else if (level === 'warning' || level === 'warn') console.warn(message);
+  else console.log(message);
+}
 
-// Helper function to format aligned console output
-const formatAligned = (icon, label, value, indent = 0) => {
+function formatAligned(icon, label, value, indent = 0) {
   const spaces = ' '.repeat(indent);
   const labelWidth = 25 - indent;
-  const paddedLabel = label.padEnd(labelWidth, ' ');
-  return `${spaces}${icon} ${paddedLabel} ${value || ''}`;
-};
-
-await log('\n🎯 Task Processing Started');
-await log(formatAligned('📝', 'Task description:', taskDescription));
-await log(formatAligned('🤖', 'Model:', argv.model));
-await log(formatAligned('💡', 'Clarify mode:', argv.clarify ? 'enabled' : 'disabled'));
-await log(formatAligned('🔍', 'Decompose mode:', argv.decompose ? 'enabled' : 'disabled'));
-await log(formatAligned('📄', 'Output format:', argv.outputFormat));
-
-const claudePath = argv.executeToolWithBun ? 'bunx claude' : process.env.CLAUDE_PATH || 'claude';
-
-// Helper function to execute Claude command
-const executeClaude = (prompt, model) => {
-  return new Promise((resolve, reject) => {
-    // Map model alias to full ID
-    const mappedModel = mapModelToId(model);
-
-    const args = ['-p', prompt, '--output-format', 'text', '--dangerously-skip-permissions', '--model', mappedModel];
+  return `${spaces}${icon} ${label.padEnd(labelWidth)} ${value || ''}`;
+}
 
-    const child = spawn(claudePath, args, {
+function runCommand(command, args, options = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: process.env,
+      ...options,
     });
-
     let stdout = '';
     let stderr = '';
-
     child.stdout.on('data', data => {
       stdout += data.toString();
     });
-
     child.stderr.on('data', data => {
       stderr += data.toString();
     });
-
+    child.on('error', error => {
+      resolve({ code: 1, stdout, stderr: stderr || error.message });
+    });
     child.on('close', code => {
-      if (code === 0) {
-        resolve(stdout.trim());
-      } else {
-        reject(new Error(`Claude exited with code ${code}: ${stderr}`));
-      }
+      resolve({ code, stdout, stderr });
     });
+  });
+}
 
-    child.on('error', error => {
-      reject(error);
-    });
+async function commandOutput(command, args, options = {}) {
+  const result = await runCommand(command, args, options);
+  if (result.code !== 0) {
+    const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
+    throw new Error(output || `${command} exited with code ${result.code}`);
+  }
+  return result.stdout.trim();
+}
+
+function buildScreenName(issue) {
+  const base = issue ? `task-split-${issue.owner}-${issue.repo}-${issue.number}` : 'task-agent';
+  return `${base}-${crypto.randomUUID().slice(0, 8)}`.replace(/[^A-Za-z0-9_.-]/g, '-');
+}
+
+async function runAgentPrompt(prompt, systemPrompt, issue = null) {
+  const startAgent = await resolveStartAgentCommand({ runCommand });
+  if (!startAgent) {
+    throw new Error('agent-commander start-agent binary not found. Run npm install so the agent-commander dependency is available, or install start-agent on PATH.');
+  }
+
+  const args = buildStartAgentArgs({
+    tool: argv.tool,
+    workingDirectory: process.cwd(),
+    prompt,
+    systemPrompt,
+    model: selectedModel,
+    isolation: argv.isolation,
+    screenName: argv.isolation === 'screen' ? argv.screenName || buildScreenName(issue) : null,
+    verbose: argv.verbose,
   });
-};
 
-try {
-  const results = {
-    task: taskDescription,
-    timestamp: new Date().toISOString(),
-    clarification: null,
-    decomposition: null,
+  await log(`Running agent-commander with tool=${argv.tool}, model=${selectedModel}, isolation=${argv.isolation}, readOnly=true`, { verbose: true });
+  const result = await runCommand(startAgent, args);
+  const output = `${result.stdout || ''}${result.stderr ? `\n${result.stderr}` : ''}`.trim();
+  if (result.code !== 0) {
+    throw new Error(output || `start-agent exited with code ${result.code}`);
+  }
+  return output;
+}
+
+async function fetchIssue(issue) {
+  const issueJson = await commandOutput('gh', ['issue', 'view', String(issue.number), '--repo', `${issue.owner}/${issue.repo}`, '--json', 'title,body,number,url,labels']);
+  const data = JSON.parse(issueJson);
+  return {
+    owner: issue.owner,
+    repo: issue.repo,
+    number: data.number,
+    url: data.url,
+    title: data.title,
+    body: data.body || '',
+    labels: Array.isArray(data.labels) ? data.labels.map(label => label.name).filter(Boolean) : [],
   };
+}
 
-  // Phase 1: Clarification
-  if (argv.clarify) {
-    await log('\n🤔 Phase 1: Task Clarification');
-    await log('   Analyzing task and generating clarifying questions...');
+async function fetchIssueRestId(issue) {
+  const id = Number(await commandOutput('gh', buildIssueRestIdApiArgs(issue)));
+  if (!Number.isInteger(id) || id <= 0) {
+    throw new Error(`Could not resolve REST id for issue #${issue.number}`);
+  }
+  return id;
+}
 
-    const clarifyPrompt = `Task: "${taskDescription}"
+async function createChildIssue(parentIssue, task, index, splitCount) {
+  const args = ['issue', 'create', '--repo', `${parentIssue.owner}/${parentIssue.repo}`, '--title', task.title, '--body', formatChildIssueBody({ parentIssue, task, index, splitCount })];
+  if (parentIssue.labels.length > 0) {
+    args.push('--label', parentIssue.labels.join(','));
+  }
 
-Please help clarify this task by:
-1. Identifying any ambiguous aspects of the task
-2. Asking 3-5 specific clarifying questions that would help someone implement this task more effectively
-3. Suggesting potential assumptions that could be made if these questions aren't answered
-4. Identifying any missing context or requirements
+  const url = await commandOutput('gh', args);
+  const parsed = parseCreatedIssueUrl(url);
+  const restId = await fetchIssueRestId(parsed);
+  return {
+    owner: parsed.owner,
+    repo: parsed.repo,
+    number: parsed.number,
+    restId,
+    url,
+    title: task.title,
+  };
+}
 
-Provide your response in a clear, structured format that helps refine the task understanding.`;
+async function linkChildIssue(parentIssue, childIssue) {
+  await commandOutput('gh', buildAddSubIssueApiArgs({ parentIssue, subIssueId: childIssue.restId }));
+}
 
-    const clarificationOutput = await executeClaude(clarifyPrompt, argv.model);
-    if (!argv.verbose) {
-      console.log('\n📝 Clarification Results:');
-      console.log(clarificationOutput);
-    }
+async function updateParentIssue(parentIssue, childIssues) {
+  const body = appendOrReplaceParentSplitSection(parentIssue.body, childIssues);
+  await commandOutput('gh', ['issue', 'edit', String(parentIssue.number), '--repo', `${parentIssue.owner}/${parentIssue.repo}`, '--body', body]);
+  const childList = childIssues.map(issue => `- #${issue.number} ${issue.title}`).join('\n');
+  await commandOutput('gh', ['issue', 'comment', String(parentIssue.number), '--repo', `${parentIssue.owner}/${parentIssue.repo}`, '--body', `Split into ${childIssues.length} tasks:\n\n${childList}`]);
+}
 
-    results.clarification = clarificationOutput;
-    await log('\n✅ Clarification phase completed');
+async function runSplitMode() {
+  const parsedIssue = parseTaskIssueUrl(taskInput);
+  if (!parsedIssue.valid) {
+    throw new Error(parsedIssue.error || 'Invalid GitHub issue URL');
   }
 
-  // Phase 2: Decomposition
-  if (argv.decompose) {
-    await log('\n🔍 Phase 2: Task Decomposition');
-    await log('   Breaking down task into manageable subtasks...');
+  const parentIssue = await fetchIssue(parsedIssue);
+  const prompt = buildTaskSplitPrompt({ issue: parentIssue, splitCount: argv.splitCount });
+  const output = await runAgentPrompt(prompt, buildTaskSplitSystemPrompt(), parentIssue);
+  const tasks = normalizeSplitTasks(extractTaskSplitJson(output), argv.splitCount);
+
+  if (argv.dryRun) {
+    return {
+      parentIssue,
+      tasks,
+      createdIssues: [],
+      dryRun: true,
+    };
+  }
 
-    let decomposePrompt = `Task: "${taskDescription}"`;
+  const createdIssues = [];
+  for (let i = 0; i < tasks.length; i++) {
+    createdIssues.push(await createChildIssue(parentIssue, tasks[i], i, tasks.length));
+  }
+  for (const childIssue of createdIssues) {
+    await linkChildIssue(parentIssue, childIssue);
+  }
+  await updateParentIssue(parentIssue, createdIssues);
 
-    if (results.clarification) {
-      decomposePrompt += `\n\nClarification analysis:\n${results.clarification}`;
-    }
+  return {
+    parentIssue,
+    tasks,
+    createdIssues,
+    dryRun: false,
+  };
+}
 
-    decomposePrompt += `\n\nPlease decompose this task by:
-1. Breaking it down into 3-8 specific, actionable subtasks
-2. Ordering the subtasks logically (dependencies and sequence)
-3. Estimating relative complexity/effort for each subtask (simple/medium/complex)
-4. Identifying any potential risks or challenges for each subtask
-5. Suggesting success criteria for each subtask
+async function runClarifyOrDecomposeMode() {
+  const results = {
+    task: taskInput,
+    timestamp: new Date().toISOString(),
+    clarification: null,
+    decomposition: null,
+  };
 
-Provide your response as a structured breakdown that someone could use as a implementation roadmap.`;
+  if (argv.clarify) {
+    const prompt = `Task: "${taskInput}"
 
-    const decompositionOutput = await executeClaude(decomposePrompt, argv.model);
-    if (!argv.verbose) {
-      console.log('\n🔍 Decomposition Results:');
-      console.log(decompositionOutput);
-    }
+Please help clarify this task by:
+1. Identifying ambiguous aspects of the task
+2. Asking 3-5 specific clarifying questions
+3. Suggesting assumptions that could be made if these questions are not answered
+4. Identifying missing context or requirements`;
+    results.clarification = await runAgentPrompt(prompt, 'Return a concise clarification analysis. Do not modify files or run commands.');
+  }
 
-    results.decomposition = decompositionOutput;
-    await log('\n✅ Decomposition phase completed');
+  if (argv.decompose) {
+    const prompt = `Task: "${taskInput}"
+
+${results.clarification ? `Clarification analysis:\n${results.clarification}\n\n` : ''}Please decompose this task into actionable subtasks with dependencies, complexity, risks, and success criteria.`;
+    results.decomposition = await runAgentPrompt(prompt, 'Return a concise decomposition. Do not modify files or run commands.');
   }
 
-  // Output results
+  return results;
+}
+
+try {
+  await fs.writeFile(logFile, `# Task Log - ${new Date().toISOString()}\n\n`);
+  await log(`📁 Log file: ${logFile}`);
+  await log('\n🎯 Task Processing Started');
+  await log(formatAligned('📝', 'Task input:', taskInput));
+  await log(formatAligned('🛠', 'Tool:', argv.tool));
+  await log(formatAligned('🤖', 'Model:', selectedModel));
+  await log(formatAligned('🔒', 'Isolation:', argv.isolation));
+  await log(formatAligned('✂️', 'Split mode:', argv.split ? `enabled (count: ${argv.splitCount})` : 'disabled'));
+
+  const result = argv.split ? await runSplitMode() : await runClarifyOrDecomposeMode();
+
   if (argv.outputFormat === 'json') {
-    console.log('\n' + JSON.stringify(results, null, 2));
+    console.log(JSON.stringify(result, null, 2));
+  } else if (argv.split) {
+    if (result.dryRun) {
+      console.log('\nPlanned split issues:');
+      result.tasks.forEach((task, index) => console.log(`${index + 1}. ${task.title}`));
+    } else {
+      console.log('\nCreated split issues:');
+      result.createdIssues.forEach(issue => console.log(`- #${issue.number} ${issue.url}`));
+    }
+  } else {
+    if (result.clarification) console.log(`\nClarification Results:\n${result.clarification}`);
+    if (result.decomposition) console.log(`\nDecomposition Results:\n${result.decomposition}`);
   }
 
   await log('\n🎉 Task processing completed successfully');
-  await log(`💡 Review the session log for details: ${logFile}`);
 } catch (error) {
   await log(`❌ Error processing task: ${error.message}`, { level: 'error' });
   process.exit(1);