@link-assistant/hive-mind 1.60.0 → 1.61.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.61.0
+
+### Minor Changes
+
+- 728b0ed: Add Telegram `/task` issue creation from repository links and issue text while preserving `/split` behavior.
+
 ## 1.60.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.60.0",
+  "version": "1.61.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/task.issue-creation.lib.mjs

@@ -0,0 +1,203 @@
+import os from 'os';
+import path from 'path';
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import { parseGitHubUrl } from './github.lib.mjs';
+
+export const TASK_ISSUE_TITLE_MAX_LENGTH = 256;
+
+function normalizeNewlines(value) {
+  return String(value || '').replace(/\r\n?/g, '\n');
+}
+
+function cleanRepositoryCandidate(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^[<([{]+/, '')
+    .replace(/[>\])}.,;:]+$/, '');
+}
+
+export function stripTaskCommandPrefix(text) {
+  const value = normalizeNewlines(text).trimStart();
+  return value.replace(/^\/(?:task|split)(?:@\S+)?(?:[ \t]+|\n|$)/i, '').trim();
+}
+
+export function resolveTaskIssueCreationInput({ commandText = '', replyText = '' } = {}) {
+  const inlineText = stripTaskCommandPrefix(commandText);
+  if (inlineText) return inlineText;
+  return normalizeNewlines(replyText).trim();
+}
+
+export function parseTaskRepository(value) {
+  const candidate = cleanRepositoryCandidate(value);
+  const parsed = parseGitHubUrl(candidate);
+  if (!parsed.valid || parsed.type !== 'repo') return null;
+  return {
+    owner: parsed.owner,
+    repo: parsed.repo,
+    fullName: `${parsed.owner}/${parsed.repo}`,
+    url: `https://github.com/${parsed.owner}/${parsed.repo}`,
+  };
+}
+
+function parseRepositoryDirective(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('--repository')) return { matched: false };
+
+  const match = trimmed.match(/^--repository(?:=(\S+)|\s+(\S+))$/);
+  if (!match) {
+    return {
+      matched: true,
+      error: 'Invalid --repository syntax. Use --repository <github-repository-url>.',
+    };
+  }
+
+  const repository = parseTaskRepository(match[1] || match[2]);
+  if (!repository) {
+    return {
+      matched: true,
+      error: '--repository must point to a GitHub repository URL.',
+    };
+  }
+
+  return { matched: true, repository };
+}
+
+function parseRepositoryLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || /\s/.test(trimmed)) return null;
+  return parseTaskRepository(trimmed);
+}
+
+function setRepository(currentRepository, nextRepository) {
+  if (!nextRepository) return { repository: currentRepository };
+  if (currentRepository) {
+    return {
+      repository: currentRepository,
+      error: 'Only one GitHub repository may be provided.',
+    };
+  }
+  return { repository: nextRepository };
+}
+
+export function buildTaskIssueTitle(issueText, maxLength = TASK_ISSUE_TITLE_MAX_LENGTH) {
+  const firstLine = normalizeNewlines(issueText).trim().split('\n')[0]?.trim() || 'New task';
+  if (firstLine.length <= maxLength) return firstLine;
+  return `${firstLine.slice(0, Math.max(0, maxLength - 3)).trimEnd()}...`;
+}
+
+export function parseTaskIssueCreationInput(input) {
+  const normalized = normalizeNewlines(input).trim();
+  if (!normalized) {
+    return { valid: false, error: 'Missing repository and issue text.' };
+  }
+
+  const lines = normalized.split('\n');
+  let repository = null;
+  let bodyLines = [];
+
+  for (const line of lines) {
+    const directive = parseRepositoryDirective(line);
+    if (!directive.matched) {
+      bodyLines.push(line);
+      continue;
+    }
+    if (directive.error) return { valid: false, error: directive.error };
+    const next = setRepository(repository, directive.repository);
+    if (next.error) return { valid: false, error: next.error };
+    repository = next.repository;
+  }
+
+  if (!repository) {
+    bodyLines = [];
+    for (const line of lines) {
+      const lineRepository = parseRepositoryLine(line);
+      if (!lineRepository) {
+        bodyLines.push(line);
+        continue;
+      }
+      const next = setRepository(repository, lineRepository);
+      if (next.error) return { valid: false, error: next.error };
+      repository = next.repository;
+    }
+  }
+
+  if (!repository) {
+    return {
+      valid: false,
+      error: 'Missing GitHub repository URL. Provide it on its own line or with --repository <github-repository-url>.',
+    };
+  }
+
+  const issueText = bodyLines.join('\n').trim();
+  if (!issueText) {
+    return { valid: false, error: 'Missing issue text.' };
+  }
+
+  return {
+    valid: true,
+    repository,
+    issueText,
+    title: buildTaskIssueTitle(issueText),
+  };
+}
+
+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 => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+}
+
+export function parseCreatedTaskIssueOutput(output) {
+  const tokens = String(output || '')
+    .split(/\s+/)
+    .filter(Boolean);
+  for (const token of tokens) {
+    const parsed = parseGitHubUrl(cleanRepositoryCandidate(token));
+    if (parsed.valid && parsed.type === 'issue') {
+      return {
+        owner: parsed.owner,
+        repo: parsed.repo,
+        number: parsed.number,
+        url: parsed.normalized,
+      };
+    }
+  }
+  throw new Error(`Could not parse created issue URL from gh output: ${String(output || '').trim()}`);
+}
+
+export async function createTaskIssue({ repository, title, body, run = runCommand }) {
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hive-mind-task-issue-'));
+  const bodyFile = path.join(tempDir, 'body.md');
+
+  try {
+    await fs.writeFile(bodyFile, body);
+    const result = await run('gh', ['issue', 'create', '--repo', repository.fullName, '--title', title, '--body-file', bodyFile]);
+    if (result.code !== 0) {
+      const output = `${result.stderr || ''}${result.stdout || ''}`.trim();
+      throw new Error(output || `gh issue create exited with code ${result.code}`);
+    }
+    return parseCreatedTaskIssueOutput(result.stdout);
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  }
+}

package/src/telegram-bot.mjs

@@ -539,8 +539,11 @@ bot.command('help', async ctx => {
   }
 
   if (taskEnabled) {
-    message += '*/task* / */split* - Split a GitHub issue into smaller issues\n';
-    message += 'Usage: `/split <github-issue-url> [options]`\n';
+    message += '*/task* - Create a GitHub issue from a repository link and issue text\n';
+    message += 'Usage: `/task <github-repository-url>` followed by issue text, or reply with `/task`\n';
+    message += 'Example: `/task https://github.com/owner/repo` then the issue text on following lines\n';
+    message += '*/split* - Split a GitHub issue into smaller issues\n';
+    message += 'Usage: `/split <github-issue-url> [options]` or `/task --split <github-issue-url>`\n';
     message += 'Example: `/split https://github.com/owner/repo/issues/123 --split-count 2`\n\n';
   } else {
     message += '*/task* / */split* - ❌ Disabled\n\n';

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

@@ -1,5 +1,6 @@
 import { buildUserMention } from './buildUserMention.lib.mjs';
 import { validateModelName } from './models/index.mjs';
+import { createTaskIssue, parseTaskIssueCreationInput, resolveTaskIssueCreationInput } from './task.issue-creation.lib.mjs';
 import { parseTaskIssueUrl } from './task.split.lib.mjs';
 import { escapeMarkdown } from './telegram-markdown.lib.mjs';
 import { extractIsolationFromArgs, isValidPerCommandIsolation } from './telegram-isolation.lib.mjs';
@@ -16,7 +17,12 @@ export function getTaskCommandNameFromText(text) {
   return TASK_COMMAND_NAMES.includes(command) ? command : null;
 }
 
-export function applyTaskCommandDefaults(args) {
+export function hasTaskSplitFlag(args) {
+  return args.includes('--split') || args.some(arg => arg.startsWith('--split='));
+}
+
+export function applyTaskCommandDefaults(args, commandName = 'task') {
+  if (commandName !== 'split') return args;
   const hasSplit = args.includes('--split') || args.some(arg => arg.startsWith('--split='));
   return hasSplit ? args : [...args, '--split'];
 }
@@ -49,7 +55,8 @@ function validateTaskModel(args) {
 }
 
 export function buildTaskCommandArgs(text) {
-  const args = applyTaskCommandDefaults(parseCommandArgs(text));
+  const commandName = getTaskCommandNameFromText(text) || 'task';
+  const args = applyTaskCommandDefaults(parseCommandArgs(text), commandName);
   const issueUrl = findTaskIssueUrl(args);
   return {
     args: issueUrl ? moveArgumentToFront(args, issueUrl) : args,
@@ -57,8 +64,26 @@ export function buildTaskCommandArgs(text) {
   };
 }
 
+function getReplyText(message) {
+  const reply = message?.reply_to_message;
+  if (!reply || reply.forum_topic_created) return '';
+  return reply.text || reply.caption || '';
+}
+
+function buildTaskIssueCreationUsage(commandDisplay) {
+  return [`Usage: ${commandDisplay} <github-repository-url> followed by issue text.`, '', `Or reply to a message containing a repository URL and issue text with \`${commandDisplay}\`.`, '', 'To split an existing issue, use `/split <github-issue-url>` or `/task --split <github-issue-url>`.'].join('\n');
+}
+
+async function editTelegramMessage(ctx, message, text) {
+  try {
+    await ctx.telegram.editMessageText(message.chat.id, message.message_id, undefined, text, { disable_web_page_preview: true });
+  } catch (error) {
+    console.error(`[telegram-task-command] Failed to edit status message: ${error.message}`);
+  }
+}
+
 export function registerTaskCommands(bot, options) {
-  const { VERBOSE, taskEnabled, addBreadcrumb, isOldMessage, isGroupChat, isTopicAuthorized, buildAuthErrorMessage, isChatStopped, getStoppedChatRejectMessage, safeReply, executeAndUpdateMessage } = options;
+  const { VERBOSE, taskEnabled, addBreadcrumb, isOldMessage, isGroupChat, isTopicAuthorized, buildAuthErrorMessage, isChatStopped, getStoppedChatRejectMessage, safeReply, executeAndUpdateMessage, createTaskIssue: createTaskIssueFn = createTaskIssue } = options;
 
   async function handleTaskCommand(ctx) {
     const commandName = getTaskCommandNameFromText(ctx.message?.text) || 'task';
@@ -90,6 +115,39 @@ export function registerTaskCommands(bot, options) {
       return;
     }
 
+    const parsedArgs = parseCommandArgs(ctx.message.text);
+    const splitMode = commandName === 'split' || hasTaskSplitFlag(parsedArgs);
+
+    if (!splitMode) {
+      const creationInput = resolveTaskIssueCreationInput({
+        commandText: ctx.message.text,
+        replyText: getReplyText(ctx.message),
+      });
+      const creation = parseTaskIssueCreationInput(creationInput);
+
+      if (!creation.valid) {
+        await safeReply(ctx, `❌ ${escapeMarkdown(creation.error)}\n\n${buildTaskIssueCreationUsage(commandDisplay)}`, { reply_to_message_id: ctx.message.message_id });
+        return;
+      }
+
+      const statusMessage = await ctx.reply(`Creating GitHub issue in ${creation.repository.fullName}...`, {
+        reply_to_message_id: ctx.message.message_id,
+        disable_web_page_preview: true,
+      });
+
+      try {
+        const createdIssue = await createTaskIssueFn({
+          repository: creation.repository,
+          title: creation.title,
+          body: creation.issueText,
+        });
+        await editTelegramMessage(ctx, statusMessage, `Created GitHub issue:\n${createdIssue.url}\n\nReply to this message with /solve to start a solution.`);
+      } catch (error) {
+        await editTelegramMessage(ctx, statusMessage, `Error creating GitHub issue:\n${error.message || String(error)}`);
+      }
+      return;
+    }
+
     const built = buildTaskCommandArgs(ctx.message.text);
     if (!built.issueUrl) {
       await safeReply(ctx, `❌ Missing GitHub issue URL. Usage: \`${commandDisplay} <github-issue-url> [options]\`\n\nExample: \`${commandDisplay} https://github.com/owner/repo/issues/123\``, { reply_to_message_id: ctx.message.message_id });