@link-assistant/hive-mind 0.39.0

package/src/start-screen.mjs

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+// start-screen.mjs - Launch solve or hive commands in GNU screen sessions
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+// Import the shared parseGitHubUrl function from github.lib.mjs
+// This ensures consistent URL validation across all commands (hive, solve, start-screen)
+const { parseGitHubUrl } = await import('./github.lib.mjs');
+
+/**
+ * Generate a screen session name based on the command and GitHub URL
+ * @param {string} command - Either 'solve' or 'hive'
+ * @param {string} githubUrl - GitHub repository or issue URL
+ * @returns {string} The generated screen session name
+ */
+function generateScreenName(command, githubUrl) {
+  const parsed = parseGitHubUrl(githubUrl);
+
+  if (!parsed.valid) {
+    // Fallback to simple naming if parsing fails
+    const sanitized = githubUrl.replace(/[^a-zA-Z0-9-]/g, '-').substring(0, 30);
+    return `${command}-${sanitized}`;
+  }
+
+  // Build name parts
+  const parts = [command];
+
+  if (parsed.owner) {
+    parts.push(parsed.owner);
+  }
+
+  if (parsed.repo) {
+    parts.push(parsed.repo);
+  }
+
+  if (parsed.number) {
+    parts.push(parsed.number);
+  }
+
+  return parts.join('-');
+}
+
+/**
+ * Check if a screen session exists
+ * @param {string} sessionName - The name of the screen session
+ * @returns {Promise<boolean>} Whether the session exists
+ */
+async function screenSessionExists(sessionName) {
+  try {
+    const { stdout } = await execAsync('screen -ls');
+    return stdout.includes(sessionName);
+  } catch {
+    // screen -ls returns non-zero exit code when no sessions exist
+    return false;
+  }
+}
+
+/**
+ * Wait for a screen session to be ready to accept commands
+ * A session is considered ready when it can execute a test command
+ * @param {string} sessionName - The name of the screen session
+ * @param {number} maxWaitSeconds - Maximum time to wait in seconds (default: 5)
+ * @returns {Promise<boolean>} Whether the session became ready
+ */
+async function waitForSessionReady(sessionName, maxWaitSeconds = 5) {
+  const startTime = Date.now();
+  const maxWaitMs = maxWaitSeconds * 1000;
+
+  // Use a unique marker file for this check to avoid conflicts
+  const markerFile = `/tmp/screen-ready-${sessionName}-${Date.now()}.marker`;
+
+  while (Date.now() - startTime < maxWaitMs) {
+    try {
+      // Send a test command that creates a marker file
+      // This command will only execute when the session is actually ready at a prompt
+      await execAsync(`screen -S ${sessionName} -X stuff "touch ${markerFile} 2>/dev/null\n"`);
+
+      // Wait for the marker file to appear
+      const checkStartTime = Date.now();
+      const checkTimeout = 1000; // 1 second to check if marker appears
+
+      while (Date.now() - checkStartTime < checkTimeout) {
+        try {
+          const { code } = await execAsync(`test -f ${markerFile}`);
+          if (code === 0) {
+            // Marker file exists, session is ready!
+            // Clean up the marker file
+            await execAsync(`rm -f ${markerFile}`).catch(() => { });
+            return true;
+          }
+        } catch {
+          // Marker file doesn't exist yet
+        }
+
+        // Wait before checking again
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+
+      // Marker file didn't appear, session is still busy
+      // Clean up any leftover marker file from the queued command
+      await execAsync(`rm -f ${markerFile}`).catch(() => { });
+    } catch {
+      // Error sending test command or checking marker
+    }
+
+    // Wait before trying again
+    await new Promise(resolve => setTimeout(resolve, 500));
+  }
+
+  // Timeout reached, session is not ready
+  return false;
+}
+
+/**
+ * Create or enter a screen session with the given command
+ * @param {string} sessionName - The name of the screen session
+ * @param {string} command - The command to run ('solve' or 'hive')
+ * @param {string[]} args - Arguments to pass to the command
+ * @param {boolean} autoTerminate - If true, session terminates after command completes
+ */
+async function createOrEnterScreen(sessionName, command, args, autoTerminate = false) {
+  const sessionExists = await screenSessionExists(sessionName);
+
+  if (sessionExists) {
+    console.log(`Screen session '${sessionName}' already exists.`);
+    console.log('Checking if session is ready to accept commands...');
+
+    // Wait for the session to be ready (at a prompt)
+    const isReady = await waitForSessionReady(sessionName);
+
+    if (isReady) {
+      console.log('Session is ready.');
+    } else {
+      console.log('Session might still be running a command. Will attempt to send command anyway.');
+      console.log('Note: The command will execute once the current operation completes.');
+    }
+
+    console.log('Sending command to existing session...');
+
+    // Build the full command to send to the existing session
+    const quotedArgs = args.map(arg => {
+      // If arg contains spaces or special chars, wrap in single quotes
+      if (arg.includes(' ') || arg.includes('&') || arg.includes('|') ||
+          arg.includes(';') || arg.includes('$') || arg.includes('*') ||
+          arg.includes('?') || arg.includes('(') || arg.includes(')')) {
+        // Escape single quotes within the argument
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+      }
+      return arg;
+    }).join(' ');
+
+    const fullCommand = `${command} ${quotedArgs}`;
+
+    // Escape the command for screen's stuff command
+    // We need to escape special characters for the shell
+    const escapedCommand = fullCommand.replace(/'/g, "'\\''");
+
+    try {
+      // Send the command to the existing screen session
+      // The \n at the end simulates pressing Enter
+      await execAsync(`screen -S ${sessionName} -X stuff '${escapedCommand}\n'`);
+      console.log(`Command sent to session '${sessionName}' successfully.`);
+      console.log(`To attach and view the session, run: screen -r ${sessionName}`);
+    } catch (error) {
+      console.error('Failed to send command to existing screen session:', error.message);
+      console.error('You may need to terminate the old session and try again.');
+      process.exit(1);
+    }
+    return;
+  }
+
+  console.log(`Creating screen session: ${sessionName}`);
+
+  // Create a detached session with the command
+  // Quote arguments properly to preserve spaces and special characters
+  const quotedArgs = args.map(arg => {
+    // If arg contains spaces or special chars, wrap in single quotes
+    if (arg.includes(' ') || arg.includes('&') || arg.includes('|') ||
+        arg.includes(';') || arg.includes('$') || arg.includes('*') ||
+        arg.includes('?') || arg.includes('(') || arg.includes(')')) {
+      // Escape single quotes within the argument
+      return `'${arg.replace(/'/g, "'\\''")}'`;
+    }
+    return arg;
+  }).join(' ');
+
+  let screenCommand;
+  if (autoTerminate) {
+    // Old behavior: session terminates after command completes
+    const fullCommand = `${command} ${quotedArgs}`;
+    screenCommand = `screen -dmS ${sessionName} ${fullCommand}`;
+  } else {
+    // New behavior: wrap the command in a bash shell that will stay alive after the command finishes
+    // This allows the user to reattach to the screen session after the command completes
+    const fullCommand = `${command} ${quotedArgs}`;
+    const escapedCommand = fullCommand.replace(/'/g, "'\\''");
+    screenCommand = `screen -dmS ${sessionName} bash -c '${escapedCommand}; exec bash'`;
+  }
+
+  try {
+    await execAsync(screenCommand);
+    console.log(`Started ${command} in detached screen session: ${sessionName}`);
+    if (autoTerminate) {
+      console.log('Note: Session will terminate after command completes (--auto-terminate mode)');
+    } else {
+      console.log('Session will remain active after command completes');
+    }
+    console.log(`To attach to this session, run: screen -r ${sessionName}`);
+  } catch (error) {
+    console.error('Failed to create screen session:', error.message);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main function
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  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');
+    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.)
+  if (args[0] && /^[\u2010\u2011\u2012\u2013\u2014]/.test(args[0])) {
+    console.error(`Unknown option: ${args[0]}`);
+    console.error('Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]');
+    console.error('Note: Use regular hyphens (--) not em-dashes or en-dashes.');
+    process.exit(1);
+  }
+
+  if (args[0] === '--auto-terminate') {
+    autoTerminate = true;
+    argsOffset = 1;
+
+    if (args.length < 3) {
+      console.error('Error: --auto-terminate requires a command and GitHub URL');
+      console.error('Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]');
+      process.exit(1);
+    }
+  } else if (args[0] && args[0].startsWith('-') && args[0] !== '--help' && args[0] !== '-h') {
+    // First arg is an unrecognized option
+    console.error(`Unknown option: ${args[0]}`);
+    console.error('Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]');
+    process.exit(1);
+  }
+
+  // Check if the next arg (after --auto-terminate if present) looks like an unrecognized option
+  if (args[argsOffset] && args[argsOffset].startsWith('-')) {
+    // Check for various dash characters (em-dash, en-dash, etc.)
+    const firstArg = args[argsOffset];
+    const hasInvalidDash = /^[\u2010\u2011\u2012\u2013\u2014]/.test(firstArg);
+    if (hasInvalidDash || (firstArg.startsWith('-') && firstArg !== '--help' && firstArg !== '-h')) {
+      console.error(`Unknown option: ${firstArg}`);
+      console.error('Usage: start-screen [--auto-terminate] <solve|hive> <github-url> [additional-args...]');
+      console.error('Expected command to be "solve" or "hive", not an option.');
+      process.exit(1);
+    }
+  }
+
+  const command = args[argsOffset];
+  const githubUrl = args[argsOffset + 1];
+  const commandArgs = args.slice(argsOffset + 2);
+
+  // Validate command
+  if (command !== 'solve' && command !== 'hive') {
+    console.error(`Error: Invalid command '${command}'. Must be 'solve' or 'hive'.`);
+    process.exit(1);
+  }
+
+  // Validate GitHub URL
+  const parsed = parseGitHubUrl(githubUrl);
+  if (!parsed.valid) {
+    console.error(`Error: Invalid GitHub URL. ${parsed.error}`);
+    console.error('Please provide a valid GitHub repository or issue URL.');
+    process.exit(1);
+  }
+
+  // Generate screen session name
+  const sessionName = generateScreenName(command, githubUrl);
+
+  // Check for screen availability
+  try {
+    await execAsync('which screen');
+  } catch {
+    console.error('Error: GNU Screen is not installed or not in PATH.');
+    console.error('Please install it using your package manager:');
+    console.error('  Ubuntu/Debian: sudo apt-get install screen');
+    console.error('  macOS: brew install screen');
+    console.error('  RHEL/CentOS: sudo yum install screen');
+    process.exit(1);
+  }
+
+  // Prepare full argument list for the command
+  const fullArgs = [githubUrl, ...commandArgs];
+
+  // Create or enter the screen session
+  await createOrEnterScreen(sessionName, command, fullArgs, autoTerminate);
+}
+
+// Run the main function
+main().catch((error) => {
+  console.error('Unexpected error:', error);
+  process.exit(1);
+});

package/src/task.mjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+
+// Early exit paths - handle these before loading all modules to speed up testing
+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);
+  } catch {
+    console.error('Error: Unable to determine version');
+    process.exit(1);
+  }
+  process.exit(0);
+}
+
+if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
+  // Show help and exit
+  console.log('Usage: task.mjs <task-description> [options]');
+  console.log('\nOptions:');
+  console.log('  --version          Show version number');
+  console.log('  --help, -h         Show help');
+  console.log('  --clarify          Enable clarification mode [default: true]');
+  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('  --verbose, -v      Enable verbose logging');
+  console.log('  --output-format    Output format (text or json) [default: text]');
+  process.exit(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';
+
+// 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: 'Model to use (opus, sonnet, or full model ID like claude-sonnet-4-5-20250929)',
+    alias: 'm',
+    default: 'sonnet',
+    choices: ['opus', 'sonnet', 'claude-sonnet-4-5-20250929', 'claude-opus-4-5-20251101']
+  })
+  .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']
+  })
+  .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];
+
+// Set global verbose mode for log function
+global.verboseMode = argv.verbose;
+
+// 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`);
+
+// 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)');
+
+// Helper function to format aligned console output
+const 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 = 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
+    ];
+    
+    const child = spawn(claudePath, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(stdout.trim());
+      } else {
+        reject(new Error(`Claude exited with code ${code}: ${stderr}`));
+      }
+    });
+    
+    child.on('error', (error) => {
+      reject(error);
+    });
+  });
+};
+
+try {
+  const results = {
+    task: taskDescription,
+    timestamp: new Date().toISOString(),
+    clarification: null,
+    decomposition: null
+  };
+
+  // Phase 1: Clarification
+  if (argv.clarify) {
+    await log('\n🤔 Phase 1: Task Clarification');
+    await log('   Analyzing task and generating clarifying questions...');
+    
+    const clarifyPrompt = `Task: "${taskDescription}"
+
+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
+
+Provide your response in a clear, structured format that helps refine the task understanding.`;
+
+    const clarificationOutput = await executeClaude(clarifyPrompt, argv.model);
+    if (!argv.verbose) {
+      console.log('\n📝 Clarification Results:');
+      console.log(clarificationOutput);
+    }
+    
+    results.clarification = clarificationOutput;
+    await log('\n✅ Clarification phase completed');
+  }
+
+  // Phase 2: Decomposition
+  if (argv.decompose) {
+    await log('\n🔍 Phase 2: Task Decomposition');
+    await log('   Breaking down task into manageable subtasks...');
+    
+    let decomposePrompt = `Task: "${taskDescription}"`;
+    
+    if (results.clarification) {
+      decomposePrompt += `\n\nClarification analysis:\n${results.clarification}`;
+    }
+    
+    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
+
+Provide your response as a structured breakdown that someone could use as a implementation roadmap.`;
+
+    const decompositionOutput = await executeClaude(decomposePrompt, argv.model);
+    if (!argv.verbose) {
+      console.log('\n🔍 Decomposition Results:');
+      console.log(decompositionOutput);
+    }
+    
+    results.decomposition = decompositionOutput;
+    await log('\n✅ Decomposition phase completed');
+  }
+
+  // Output results
+  if (argv.outputFormat === 'json') {
+    console.log('\n' + JSON.stringify(results, null, 2));
+  }
+
+  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);
+}