@link-assistant/hive-mind 1.59.7 → 1.60.0

package/src/task.split.lib.mjs

@@ -0,0 +1,221 @@
+import { parseGitHubUrl } from './github.lib.mjs';
+
+export const TASK_SPLIT_MARKER_START = '<!-- hive-mind-task-split:start -->';
+export const TASK_SPLIT_MARKER_END = '<!-- hive-mind-task-split:end -->';
+export const GITHUB_SUB_ISSUES_API_VERSION = '2026-03-10';
+
+export function parseTaskIssueUrl(url) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed.valid) {
+    return parsed;
+  }
+  if (parsed.type !== 'issue') {
+    return {
+      valid: false,
+      error: parsed.type === 'pull' ? 'The task command accepts GitHub issues, not pull requests' : 'The task command requires a specific GitHub issue URL',
+      parsed,
+    };
+  }
+  return parsed;
+}
+
+export function buildTaskSplitSystemPrompt() {
+  return ['You split GitHub issues into smaller GitHub issues.', 'Read only the issue details supplied by the user.', 'Do not clone repositories, create branches, edit files, create GitHub issues, or execute shell commands.', 'Return only valid JSON matching the requested schema.'].join('\n');
+}
+
+export function buildTaskSplitPrompt({ issue, splitCount }) {
+  return `Split this GitHub issue into exactly ${splitCount} smaller GitHub issues.
+
+Source issue:
+- Repository: ${issue.owner}/${issue.repo}
+- Issue number: ${issue.number}
+- URL: ${issue.url}
+- Title: ${issue.title}
+
+Issue body:
+${issue.body || '(empty)'}
+
+Return only this JSON shape:
+{
+  "tasks": [
+    {
+      "title": "short issue title",
+      "body": "complete issue body with objective, scope, deliverables, and acceptance criteria",
+      "dependencies": [1]
+    }
+  ]
+}
+
+Rules:
+- The tasks array must contain exactly ${splitCount} items.
+- Each task must be independently actionable.
+- Together the tasks must cover the full source issue.
+- Dependencies must be 1-based task numbers and should be empty when none are needed.
+- Do not include Markdown fences, prose, comments, or extra top-level keys.`;
+}
+
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function extractFencedBlocks(text) {
+  const blocks = [];
+  const regex = /```(?:json)?\s*([\s\S]*?)```/gi;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    blocks.push(match[1].trim());
+  }
+  return blocks;
+}
+
+function findBalancedJsonCandidates(text) {
+  const candidates = [];
+  const stack = [];
+  let start = -1;
+  let inString = false;
+  let escape = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (inString) {
+      if (escape) escape = false;
+      else if (char === '\\') escape = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === '{' || char === '[') {
+      if (stack.length === 0) start = i;
+      stack.push(char);
+    } else if ((char === '}' || char === ']') && stack.length > 0) {
+      const open = stack.pop();
+      if ((open === '{' && char !== '}') || (open === '[' && char !== ']')) {
+        stack.length = 0;
+        start = -1;
+        continue;
+      }
+      if (stack.length === 0 && start >= 0) {
+        candidates.push(text.slice(start, i + 1));
+        start = -1;
+      }
+    }
+  }
+
+  return candidates;
+}
+
+function collectStringValues(value, out = []) {
+  if (typeof value === 'string') {
+    out.push(value);
+  } else if (Array.isArray(value)) {
+    for (const item of value) collectStringValues(item, out);
+  } else if (value && typeof value === 'object') {
+    for (const item of Object.values(value)) collectStringValues(item, out);
+  }
+  return out;
+}
+
+export function extractTaskSplitJson(output) {
+  const candidates = [output.trim(), ...extractFencedBlocks(output), ...findBalancedJsonCandidates(output)];
+
+  for (const candidate of candidates) {
+    const parsed = tryParseJson(candidate);
+    if (parsed && (Array.isArray(parsed) || Array.isArray(parsed.tasks))) return parsed;
+  }
+
+  for (const line of output.split('\n')) {
+    const parsedLine = tryParseJson(line.trim());
+    if (!parsedLine) continue;
+    for (const value of collectStringValues(parsedLine)) {
+      for (const candidate of [value, ...extractFencedBlocks(value), ...findBalancedJsonCandidates(value)]) {
+        const parsed = tryParseJson(candidate.trim());
+        if (parsed && (Array.isArray(parsed) || Array.isArray(parsed.tasks))) return parsed;
+      }
+    }
+  }
+
+  throw new Error('AI output did not contain valid task split JSON');
+}
+
+export function normalizeSplitTasks(parsed, splitCount) {
+  const tasks = Array.isArray(parsed) ? parsed : parsed?.tasks;
+  if (!Array.isArray(tasks)) {
+    throw new Error('Split JSON must contain a tasks array');
+  }
+  if (tasks.length !== splitCount) {
+    throw new Error(`Expected exactly ${splitCount} split tasks, received ${tasks.length}`);
+  }
+
+  return tasks.map((task, index) => {
+    const title = String(task?.title || '').trim();
+    const body = String(task?.body || task?.description || '').trim();
+    if (!title) throw new Error(`Split task ${index + 1} is missing a title`);
+    if (!body) throw new Error(`Split task ${index + 1} is missing a body`);
+
+    const dependencies = Array.isArray(task.dependencies) ? task.dependencies.map(value => Number(value)).filter(value => Number.isInteger(value) && value >= 1 && value <= splitCount && value !== index + 1) : [];
+
+    return {
+      title: title.slice(0, 256),
+      body,
+      dependencies: [...new Set(dependencies)],
+    };
+  });
+}
+
+export function formatChildIssueBody({ parentIssue, task, index, splitCount }) {
+  const dependencyText = task.dependencies.length > 0 ? task.dependencies.map(number => `Task ${number}`).join(', ') : 'None';
+  return `${task.body}
+
+---
+
+Split from: ${parentIssue.url}
+Parent issue: #${parentIssue.number}
+Split task: ${index + 1} of ${splitCount}
+Dependencies: ${dependencyText}`;
+}
+
+export function formatParentSplitSection({ childIssues }) {
+  const lines = [TASK_SPLIT_MARKER_START, '## Split Tasks', '', ...childIssues.map((issue, index) => `- [ ] #${issue.number} ${issue.title || `Split task ${index + 1}`}`), TASK_SPLIT_MARKER_END];
+  return lines.join('\n');
+}
+
+export function appendOrReplaceParentSplitSection(body, childIssues) {
+  const section = formatParentSplitSection({ childIssues });
+  const currentBody = body || '';
+  const start = currentBody.indexOf(TASK_SPLIT_MARKER_START);
+  const end = currentBody.indexOf(TASK_SPLIT_MARKER_END);
+
+  if (start >= 0 && end > start) {
+    return `${currentBody.slice(0, start).trimEnd()}\n\n${section}\n\n${currentBody.slice(end + TASK_SPLIT_MARKER_END.length).trimStart()}`.trim();
+  }
+
+  return `${currentBody.trimEnd()}\n\n${section}`.trim();
+}
+
+export function parseCreatedIssueUrl(url) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed.valid || parsed.type !== 'issue') {
+    throw new Error(`Could not parse created issue URL: ${url}`);
+  }
+  return parsed;
+}
+
+export function buildIssueRestIdApiArgs(issue) {
+  return ['api', `repos/${issue.owner}/${issue.repo}/issues/${issue.number}`, '--jq', '.id'];
+}
+
+export function buildAddSubIssueApiArgs({ parentIssue, subIssueId }) {
+  const numericId = Number(subIssueId);
+  if (!Number.isInteger(numericId) || numericId <= 0) {
+    throw new Error(`Invalid sub-issue REST id: ${subIssueId}`);
+  }
+
+  return ['api', '-X', 'POST', `repos/${parentIssue.owner}/${parentIssue.repo}/issues/${parentIssue.number}/sub_issues`, '-H', 'Accept: application/vnd.github+json', '-H', `X-GitHub-Api-Version: ${GITHUB_SUB_ISSUES_API_VERSION}`, '-F', `sub_issue_id=${numericId}`];
+}

package/src/telegram-bot.mjs

@@ -6,12 +6,6 @@ if (process.argv.includes('--version')) {
   process.exit(v === 'unknown' ? 1 : 0);
 }
 
-import { spawn } from 'child_process';
-import { promisify } from 'util';
-import { exec as execCallback } from 'child_process';
-
-const exec = promisify(execCallback);
-
 if (typeof use === 'undefined') {
   globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
 }
@@ -20,22 +14,16 @@ const { lino } = await import('./lino.lib.mjs');
 const { buildUserMention } = await import('./buildUserMention.lib.mjs');
 const { reportError, initializeSentry, addBreadcrumb } = await import('./sentry.lib.mjs');
 const { loadLenvConfig } = await import('./lenv-reader.lib.mjs');
+const { getLinoYargsFactory, getenv, hideBin } = await import('./cli-arguments.lib.mjs');
 
 const dotenvxModule = await use('@dotenvx/dotenvx');
 const dotenvx = dotenvxModule.default || dotenvxModule;
-const getenvModule = await use('getenv');
-const getenv = typeof getenvModule === 'function' ? getenvModule : getenvModule.default || getenvModule;
-const { resolveYargsFactory } = await import('./yargs-factory.lib.mjs');
 
 // Load .env/.lenv configuration (issue #1318)
 dotenvx.config({ quiet: true, ignore: ['MISSING_ENV_FILE'] });
 await loadLenvConfig({ override: true, quiet: true });
 
-const yargsModule = await use('yargs@17.7.2');
-const yargs = resolveYargsFactory(yargsModule);
-const helpersModuleBot = await use('yargs@17.7.2/helpers');
-const _helpersBot = helpersModuleBot.default || helpersModuleBot;
-const hideBin = _helpersBot.hideBin || (argv => argv.slice(2));
+const yargs = getLinoYargsFactory();
 const { createYargsConfig: createSolveYargsConfig, detectMalformedFlags } = await import('./solve.config.lib.mjs');
 const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config.lib.mjs');
 const { parseGitHubUrl, validateGitHubEntityExistence } = await import('./github.lib.mjs');
@@ -47,6 +35,7 @@ const { getVersionInfo, formatVersionMessage } = await import('./version-info.li
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
 const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
+const { executeStartScreen: executeStartScreenCommand } = await import('./telegram-command-execution.lib.mjs');
 const { isChatStopped, getChatStopInfo, getStoppedChatRejectMessage, DEFAULT_STOP_REASON } = await import('./telegram-start-stop-command.lib.mjs');
 const { isOldMessage: _isOldMessage, isGroupChat: _isGroupChat, isChatAuthorized: _isChatAuthorized, isForwardedOrReply: _isForwardedOrReply, extractCommandFromText, extractGitHubUrl: _extractGitHubUrl } = await import('./telegram-message-filters.lib.mjs');
 const { safeReply } = await import('./telegram-safe-reply.lib.mjs');
@@ -103,6 +92,11 @@ const config = yargs(hideBin(process.argv))
     description: 'Enable /hive command (use --no-hive to disable)',
     default: getenv('TELEGRAM_HIVE', 'true') !== 'false',
   })
+  .option('task', {
+    type: 'boolean',
+    description: 'Enable /task and /split commands (use --no-task to disable)',
+    default: getenv('TELEGRAM_TASK', 'true') !== 'false',
+  })
   .option('dryRun', {
     type: 'boolean',
     description: 'Validate configuration and options without starting the bot',
@@ -162,6 +156,7 @@ const hiveOverrides = resolvedHiveOverrides
   : [];
 const solveEnabled = config.solve;
 const hiveEnabled = config.hive;
+const taskEnabled = config.task;
 // Isolation mode (experimental): uses `$` from start-command with specified backend
 const ISOLATION_BACKEND = (config.isolation || getenv('TELEGRAM_ISOLATION', '')).trim().toLowerCase();
 let isolationRunner = null;
@@ -282,7 +277,7 @@ if (config.dryRun) {
   if (allowedTopics && allowedTopics.length > 0) {
     console.log('  Allowed topics:', lino.formatLinks(allowedTopics));
   }
-  console.log('  Commands enabled:', { solve: solveEnabled, hive: hiveEnabled });
+  console.log('  Commands enabled:', { solve: solveEnabled, hive: hiveEnabled, task: taskEnabled });
   if (solveOverrides.length > 0) {
     console.log('  Solve overrides:', lino.format(solveOverrides));
   }
@@ -336,102 +331,12 @@ function isOldMessage(ctx) {
   return _isOldMessage(ctx, BOT_START_TIME, { verbose: VERBOSE });
 }
 
-function isForwardedOrReply(ctx) {
-  return _isForwardedOrReply(ctx, { verbose: VERBOSE });
-}
-
-async function findStartScreenCommand() {
-  try {
-    const { stdout } = await exec('which start-screen');
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-
 async function executeStartScreen(command, args) {
-  try {
-    // Check if start-screen is available BEFORE first execution
-    const whichPath = await findStartScreenCommand();
-
-    if (!whichPath) {
-      const warningMsg = '⚠️  WARNING: start-screen command not found in PATH\n' + 'Please ensure @link-assistant/hive-mind is properly installed\n' + 'You may need to run: npm install -g @link-assistant/hive-mind';
-      console.warn(warningMsg);
-
-      // Still try to execute with 'start-screen' in case it's available in PATH but 'which' failed
-      return {
-        success: false,
-        warning: warningMsg,
-        error: 'start-screen command not found in PATH',
-      };
-    }
-
-    // Use the resolved path from which
-    if (VERBOSE) {
-      console.log(`[VERBOSE] Found start-screen at: ${whichPath}`);
-    }
-
-    return await executeWithCommand(whichPath, command, args);
-  } catch (error) {
-    console.error('Error executing start-screen:', error);
-    return {
-      success: false,
-      output: '',
-      error: error.message,
-    };
-  }
+  return executeStartScreenCommand(command, args, { verbose: VERBOSE });
 }
 
-function executeWithCommand(startScreenCmd, command, args) {
-  return new Promise(resolve => {
-    const allArgs = [command, ...args];
-
-    if (VERBOSE) {
-      console.log(`[VERBOSE] Executing: ${startScreenCmd} ${allArgs.join(' ')}`);
-    } else {
-      console.log(`Executing: ${startScreenCmd} ${allArgs.join(' ')}`);
-    }
-
-    const child = spawn(startScreenCmd, allArgs, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      detached: false,
-      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('error', error => {
-      resolve({
-        success: false,
-        output: stdout,
-        error: error.message,
-      });
-    });
-
-    child.on('close', code => {
-      if (code === 0) {
-        resolve({
-          success: true,
-          output: stdout,
-        });
-      } else {
-        resolve({
-          success: false,
-          output: stdout,
-          error: stderr || `Command exited with code ${code}`,
-        });
-      }
-    });
-  });
+function isForwardedOrReply(ctx) {
+  return _isForwardedOrReply(ctx, { verbose: VERBOSE });
 }
 
 /**
@@ -633,6 +538,14 @@ bot.command('help', async ctx => {
     message += '*/solve* (aliases: */do*, */continue*, */claude*, */codex*, */opencode*, */agent*) - ❌ Disabled\n\n';
   }
 
+  if (taskEnabled) {
+    message += '*/task* / */split* - Split a GitHub issue into smaller issues\n';
+    message += 'Usage: `/split <github-issue-url> [options]`\n';
+    message += 'Example: `/split https://github.com/owner/repo/issues/123 --split-count 2`\n\n';
+  } else {
+    message += '*/task* / */split* - ❌ Disabled\n\n';
+  }
+
   if (hiveEnabled) {
     message += '*/hive* - Run hive command\n';
     message += 'Usage: `/hive <github-url> [options]`\n';
@@ -660,7 +573,7 @@ bot.command('help', async ctx => {
   message += '🔔 *Session Notifications:* Completion notifications are automatic; use /subscribe for private DM forwards.\n';
   if (ISOLATION_BACKEND) message += `🔒 *Isolation Mode:* \`${ISOLATION_BACKEND}\` (experimental)\n`;
   message += '\n';
-  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /do, /continue, /claude, /codex, /opencode, /agent, /task, /split, /hive, /solve\\_queue, /limits, /version, /accept\\_invites, /merge, /stop and /start commands only work in group chats. /terminal\\_watch, /subscribe and /unsubscribe work in private and group chats.\n\n';
   message += '🔧 *Common Options:*\n';
   message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
@@ -765,6 +678,8 @@ const { registerSolveQueueCommand } = await import('./telegram-solve-queue-comma
 const { handleSolveQueueCommand } = registerSolveQueueCommand(bot, { ...sharedCommandOpts, getSolveQueue });
 const { registerSubscribeCommands } = await import('./telegram-subscribers.lib.mjs'); // #1688
 registerSubscribeCommands(bot, sharedCommandOpts);
+const { registerTaskCommands } = await import('./telegram-task-command.lib.mjs');
+const { handleTaskCommand, TASK_COMMAND_NAMES } = registerTaskCommands(bot, { ...sharedCommandOpts, taskEnabled, safeReply, executeAndUpdateMessage });
 
 // Named handler for /solve command - extracted for reuse by text-based fallback (issue #1207)
 async function handleSolveCommand(ctx) {
@@ -1255,7 +1170,8 @@ bot.on('message', async (ctx, next) => {
 
   // /subscribe + /unsubscribe (#1688) are intentionally not in the text fallback — Telegraf's bot.command() is sufficient.
   const solveHandlers = Object.fromEntries(SOLVE_COMMAND_NAMES.map(command => [command, handleSolveCommand]));
-  const handlers = { ...solveHandlers, hive: handleHiveCommand, solve_queue: handleSolveQueueCommand, solvequeue: handleSolveQueueCommand };
+  const taskHandlers = Object.fromEntries(TASK_COMMAND_NAMES.map(command => [command, handleTaskCommand]));
+  const handlers = { ...solveHandlers, ...taskHandlers, hive: handleHiveCommand, solve_queue: handleSolveQueueCommand, solvequeue: handleSolveQueueCommand };
 
   const handler = handlers[extracted.command];
   if (!handler) return next();
@@ -1366,7 +1282,7 @@ if (allowedChats && allowedChats.length > 0) {
 if (allowedTopics && allowedTopics.length > 0) {
   console.log('Allowed topics (lino):', lino.formatLinks(allowedTopics));
 }
-console.log('Commands enabled:', { solve: solveEnabled, hive: hiveEnabled });
+console.log('Commands enabled:', { solve: solveEnabled, hive: hiveEnabled, task: taskEnabled });
 if (solveOverrides.length > 0) console.log('Solve overrides (lino):', lino.format(solveOverrides));
 if (hiveOverrides.length > 0) console.log('Hive overrides (lino):', lino.format(hiveOverrides));
 if (VERBOSE) {

package/src/telegram-command-execution.lib.mjs

@@ -0,0 +1,98 @@
+import { spawn } from 'child_process';
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+async function findStartScreenCommand() {
+  try {
+    const { stdout } = await exec('which start-screen');
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+
+function executeWithCommand(startScreenCmd, command, args, verbose = false) {
+  return new Promise(resolve => {
+    const allArgs = [command, ...args];
+
+    if (verbose) {
+      console.log(`[VERBOSE] Executing: ${startScreenCmd} ${allArgs.join(' ')}`);
+    } else {
+      console.log(`Executing: ${startScreenCmd} ${allArgs.join(' ')}`);
+    }
+
+    const child = spawn(startScreenCmd, allArgs, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: false,
+      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('error', error => {
+      resolve({
+        success: false,
+        output: stdout,
+        error: error.message,
+      });
+    });
+
+    child.on('close', code => {
+      if (code === 0) {
+        resolve({
+          success: true,
+          output: stdout,
+        });
+      } else {
+        resolve({
+          success: false,
+          output: stdout,
+          error: stderr || `Command exited with code ${code}`,
+        });
+      }
+    });
+  });
+}
+
+export async function executeStartScreen(command, args, options = {}) {
+  const { verbose = false } = options;
+
+  try {
+    const whichPath = await findStartScreenCommand();
+
+    if (!whichPath) {
+      const warningMsg = '⚠️  WARNING: start-screen command not found in PATH\n' + 'Please ensure @link-assistant/hive-mind is properly installed\n' + 'You may need to run: npm install -g @link-assistant/hive-mind';
+      console.warn(warningMsg);
+
+      return {
+        success: false,
+        warning: warningMsg,
+        error: 'start-screen command not found in PATH',
+      };
+    }
+
+    if (verbose) {
+      console.log(`[VERBOSE] Found start-screen at: ${whichPath}`);
+    }
+
+    return await executeWithCommand(whichPath, command, args, verbose);
+  } catch (error) {
+    console.error('Error executing start-screen:', error);
+    return {
+      success: false,
+      output: '',
+      error: error.message,
+    };
+  }
+}

package/src/telegram-solve-queue.lib.mjs

@@ -141,6 +141,7 @@ export class SolveQueue {
     this.messageUpdateCallback = options.messageUpdateCallback || null;
     this.getRunningProcessesFn = options.getRunningProcesses || getRunningProcesses;
     this.getRunningIsolatedSessionsFn = options.getRunningIsolatedSessions || getRunningIsolatedSessions;
+    this.autoStart = options.autoStart !== false;
 
     // Separate queues per tool type - claude tasks never block agent tasks
     // See: https://github.com/link-assistant/hive-mind/issues/1159
@@ -241,7 +242,7 @@ export class SolveQueue {
     this.log(`Enqueued: ${item.toString()} to ${item.tool} queue, queue length: ${toolQueue.length}`);
 
     // Start consumer if not already running
-    this.ensureConsumerRunning();
+    if (this.autoStart) this.ensureConsumerRunning();
 
     return item;
   }