@link-assistant/hive-mind 1.56.5 → 1.56.7

package/src/telegram-bot.mjs

@@ -45,7 +45,7 @@ const { formatUsageMessage, formatCodexLimitsSection, getAllCachedLimits } = awa
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
 const { getSolveQueue, createQueueExecuteCallback } = await import('./telegram-solve-queue.lib.mjs');
-const { applySolveToolAlias, getSolveCommandNameFromText, getSolveToolAliasFromText, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.lib.mjs');
+const { applySolveToolAlias, getFirstParsedPositionalArg, getSolveCommandNameFromText, getSolveToolAliasFromText, moveArgumentToFront, parseArgsWithYargs, parseCommandArgs, SOLVE_COMMAND_NAMES } = await import('./telegram-solve-command.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 { launchBotWithRetry } = await import('./telegram-bot-launcher.lib.mjs');
@@ -500,11 +500,18 @@ function mergeArgsWithOverrides(userArgs, overrides) {
 }
 
 /** Validate GitHub URL for Telegram bot commands. Returns { valid, error?, parsed?, normalizedUrl? } */
-function validateGitHubUrl(args, options = {}) {
-  const { allowedTypes = ['issue', 'pull'], commandName = 'solve' } = options;
-  if (args.length === 0) return { valid: false, error: `Missing GitHub URL. Usage: /${commandName} <github-url> [options]` };
+async function getCommandUrlArg(args, createYargsConfig, positionalNames) {
+  const parsedUrl = createYargsConfig ? await getFirstParsedPositionalArg(args, yargs, createYargsConfig, positionalNames) : null;
+  if (parsedUrl) return parsedUrl;
+  return args.find(arg => cleanNonPrintableChars(arg).includes('github.com')) || (args[0] && !args[0].startsWith('-') ? args[0] : null);
+}
+
+async function validateGitHubUrl(args, options = {}) {
+  const { allowedTypes = ['issue', 'pull'], commandName = 'solve', createYargsConfig = null, positionalNames = [] } = options;
+  const rawUrl = await getCommandUrlArg(args, createYargsConfig, positionalNames);
+  if (!rawUrl) return { valid: false, error: `Missing GitHub URL. Usage: /${commandName} <github-url> [options]` };
   // Issue #1102: Clean non-printable chars (Zero-Width Space, BOM, etc.) from URLs
-  const url = cleanNonPrintableChars(args[0]);
+  const url = cleanNonPrintableChars(rawUrl);
   if (!url.includes('github.com')) return { valid: false, error: 'First argument must be a GitHub URL' };
   const parsed = parseGitHubUrl(url);
   if (!parsed.valid) return { valid: false, error: parsed.error || 'Invalid GitHub URL', suggestion: parsed.suggestion };
@@ -842,11 +849,12 @@ async function handleSolveCommand(ctx) {
   // Issue #1325: Support all options via /solve command when replying (e.g., "/solve --model opus")
   const isReply = message.reply_to_message && message.reply_to_message.message_id && !message.reply_to_message.forum_topic_created;
 
-  // Check if the first argument looks like a GitHub URL
-  // If not, we should try to extract the URL from the replied message
-  const firstArgIsUrl = userArgs.length > 0 && (userArgs[0].includes('github.com') || userArgs[0].match(/^https?:\/\//));
+  // Check if yargs sees a command URL. If not, try to extract it from the replied message.
+  const commandUrlArg = await getCommandUrlArg(userArgs, createSolveYargsConfig, ['issue-url']);
+  const commandUrlText = commandUrlArg ? cleanNonPrintableChars(commandUrlArg) : '';
+  const commandHasUrl = commandUrlText.includes('github.com') || /^https?:\/\//.test(commandUrlText);
 
-  if (isReply && !firstArgIsUrl) {
+  if (isReply && !commandHasUrl) {
     if (VERBOSE) {
       console.log('[VERBOSE] /solve is a reply without URL in args, extracting from replied message...');
       console.log('[VERBOSE] User args:', userArgs);
@@ -883,7 +891,13 @@ async function handleSolveCommand(ctx) {
 
   userArgs = applySolveToolAlias(userArgs, solveToolAlias);
 
-  const validation = validateGitHubUrl(userArgs);
+  const { malformed, errors: malformedErrors } = detectMalformedFlags(userArgs);
+  if (malformed.length > 0) {
+    await safeReply(ctx, `❌ ${escapeMarkdown(malformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+
+  const validation = await validateGitHubUrl(userArgs, { createYargsConfig: createSolveYargsConfig, positionalNames: ['issue-url'] });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) {
@@ -893,6 +907,7 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, errorMsg, { reply_to_message_id: ctx.message.message_id });
     return;
   }
+  userArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const { backend: solvePerCommandIsolation, filteredArgs: userArgsWithoutIsolation } = extractIsolationFromArgs(userArgs); // issue #1534
   if (solvePerCommandIsolation && !isValidPerCommandIsolation(solvePerCommandIsolation)) {
     await safeReply(ctx, `❌ Invalid --isolation value '${escapeMarkdown(solvePerCommandIsolation)}'. Must be: screen, tmux, or docker`, { reply_to_message_id: ctx.message.message_id });
@@ -928,27 +943,14 @@ async function handleSolveCommand(ctx) {
     await safeReply(ctx, `❌ ${escapeMarkdown(branchError)}`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
-  // Issue #1092: Detect malformed flag patterns like "-- model" (space after --)
-  const { malformed, errors: malformedErrors } = detectMalformedFlags(args);
-  if (malformed.length > 0) {
-    await safeReply(ctx, `❌ ${escapeMarkdown(malformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
+  const { malformed: mergedMalformed, errors: mergedMalformedErrors } = detectMalformedFlags(args);
+  if (mergedMalformed.length > 0) {
+    await safeReply(ctx, `❌ ${escapeMarkdown(mergedMalformedErrors.join('\n'))}\n\nPlease check your option syntax.`, { reply_to_message_id: ctx.message.message_id });
     return;
   }
   // Validate merged arguments using solve's yargs config
   try {
-    // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-    const testYargs = createSolveYargsConfig(yargs());
-
-    // Configure yargs to throw errors instead of trying to exit the process
-    // This prevents confusing error messages when validation fails but execution continues
-    let failureMessage = null;
-    testYargs.exitProcess(false).fail((msg, err) => {
-      // Capture the failure message instead of letting yargs print it
-      failureMessage = msg || (err && err.message) || 'Unknown validation error';
-      throw new Error(failureMessage);
-    });
-
-    testYargs.parse(args);
+    await parseArgsWithYargs(args, yargs, createSolveYargsConfig);
   } catch (error) {
     await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,
@@ -1095,7 +1097,7 @@ async function handleHiveCommand(ctx) {
   const userArgs = parseCommandArgs(ctx.message.text);
 
   // Issue #1102: Allow issues_list/pulls_list URLs and normalize to repo URLs
-  const validation = validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive' });
+  const validation = await validateGitHubUrl(userArgs, { allowedTypes: ['repo', 'organization', 'user', 'issues_list', 'pulls_list'], commandName: 'hive', createYargsConfig: createHiveYargsConfig, positionalNames: ['github-url'] });
   if (!validation.valid) {
     let errorMsg = `❌ ${validation.error}`;
     if (validation.suggestion) errorMsg += `\n\n💡 Did you mean: \`${escapeMarkdown(validation.suggestion)}\``;
@@ -1104,7 +1106,7 @@ async function handleHiveCommand(ctx) {
     return;
   }
   // Normalize issues_list/pulls_list to base repo URL, or use cleaned URL
-  let normalizedArgs = [...userArgs];
+  let normalizedArgs = moveArgumentToFront(userArgs, validation.normalizedUrl, cleanNonPrintableChars);
   const p = validation.parsed;
   if (p && (p.type === 'issues_list' || p.type === 'pulls_list')) {
     normalizedArgs[0] = `https://github.com/${p.owner}/${p.repo}`;
@@ -1149,19 +1151,7 @@ async function handleHiveCommand(ctx) {
 
   // Validate merged arguments using hive's yargs config
   try {
-    // Use .parse() instead of yargs(args).parseSync() to ensure .strict() mode works
-    const testYargs = createHiveYargsConfig(yargs());
-
-    // Configure yargs to throw errors instead of trying to exit the process
-    // This prevents confusing error messages when validation fails but execution continues
-    let failureMessage = null;
-    testYargs.exitProcess(false).fail((msg, err) => {
-      // Capture the failure message instead of letting yargs print it
-      failureMessage = msg || (err && err.message) || 'Unknown validation error';
-      throw new Error(failureMessage);
-    });
-
-    testYargs.parse(args);
+    await parseArgsWithYargs(args, yargs, createHiveYargsConfig);
   } catch (error) {
     await safeReply(ctx, `❌ Invalid options: ${escapeMarkdown(error.message || String(error))}\n\nUse /help to see available options`, {
       reply_to_message_id: ctx.message.message_id,

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

@@ -59,6 +59,64 @@ export function parseCommandArgs(text) {
   return args;
 }
 
+function toCamelCaseOptionName(name) {
+  return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+export function getYargsPositionalArg(argv, positionalNames = []) {
+  if (!argv || typeof argv !== 'object') return null;
+
+  for (const name of positionalNames) {
+    const aliases = [name, toCamelCaseOptionName(name)];
+    for (const alias of aliases) {
+      if (typeof argv[alias] === 'string' && argv[alias].trim()) return argv[alias];
+    }
+  }
+
+  if (Array.isArray(argv._)) {
+    return argv._.find(value => typeof value === 'string' && value.trim()) || null;
+  }
+
+  return null;
+}
+
+export async function parseArgsWithYargs(args, yargsFactory, createYargsConfig) {
+  const originalStderrWrite = process.stderr.write;
+  process.stderr.write = (_chunk, encoding, callback) => {
+    if (typeof encoding === 'function') encoding();
+    else if (typeof callback === 'function') callback();
+    return true;
+  };
+  try {
+    const parser = createYargsConfig(yargsFactory());
+    parser
+      .exitProcess(false)
+      .showHelpOnFail(false)
+      .fail((msg, err) => {
+        throw err || new Error(msg || 'Invalid arguments');
+      });
+    return await parser.parse(args);
+  } finally {
+    process.stderr.write = originalStderrWrite;
+  }
+}
+
+export async function getFirstParsedPositionalArg(args, yargsFactory, createYargsConfig, positionalNames = []) {
+  try {
+    return getYargsPositionalArg(await parseArgsWithYargs(args, yargsFactory, createYargsConfig), positionalNames);
+  } catch {
+    return null;
+  }
+}
+
+export function moveArgumentToFront(args, target, normalize = value => value) {
+  if (!target) return [...args];
+  const normalizedTarget = normalize(target);
+  const index = args.findIndex(arg => normalize(arg) === normalizedTarget);
+  if (index < 0) return [normalizedTarget, ...args];
+  return [normalizedTarget, ...args.slice(0, index), ...args.slice(index + 1)];
+}
+
 export function getSolveCommandNameFromText(text) {
   if (!text || typeof text !== 'string') {
     return null;

package/src/tool-retry.lib.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+import { retryLimits } from './config.lib.mjs';
+import { resolveDefaultFallbackModel, resolveModelId } from './models/index.mjs';
+
+const normalizeMessage = value => {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value?.error?.message === 'string') return value.error.message;
+  if (typeof value?.message === 'string') return value.message;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const normalizeModelKey = value => {
+  if (!value) return '';
+  return String(value)
+    .toLowerCase()
+    .replace(/\[1m\]$/i, '')
+    .trim();
+};
+
+export const classifyRetryableError = value => {
+  const message = normalizeMessage(value);
+  const lower = message.toLowerCase();
+
+  if (lower.includes('selected model is at capacity') || (lower.includes('at capacity') && lower.includes('try a different model'))) {
+    return { message, isRetryable: true, isCapacity: true, label: 'Model capacity error' };
+  }
+
+  if (lower.includes('overloaded') || lower.includes('overloaded_error')) {
+    return { message, isRetryable: true, isCapacity: true, label: 'API overload' };
+  }
+
+  if (lower.includes('request timed out')) {
+    return { message, isRetryable: true, isCapacity: false, label: 'Request timeout' };
+  }
+
+  if (lower.includes('api error: 503') || (lower.includes('503') && (lower.includes('upstream connect error') || lower.includes('remote connection failure')))) {
+    return { message, isRetryable: true, isCapacity: false, label: '503 network error' };
+  }
+
+  if (lower.includes('internal server error') || lower.includes('api error: 500')) {
+    return { message, isRetryable: true, isCapacity: false, label: 'Internal server error (500)' };
+  }
+
+  return { message, isRetryable: false, isCapacity: false, label: null };
+};
+
+export const getRetryDelayMs = ({ retryCount, initialDelayMs = retryLimits.initialTransientErrorDelayMs, maxDelayMs = retryLimits.maxTransientErrorDelayMs } = {}) => {
+  return Math.min(initialDelayMs * Math.pow(retryLimits.retryBackoffMultiplier, retryCount), maxDelayMs);
+};
+
+export const waitWithCountdown = async (delayMs, log) => {
+  if (delayMs <= 60000) {
+    await new Promise(resolve => setTimeout(resolve, delayMs));
+    return;
+  }
+
+  let remaining = delayMs;
+  const timer = setInterval(async () => {
+    remaining -= 60000;
+    if (remaining > 0) await log(`⏳ ${Math.round(remaining / 60000)} min remaining...`);
+  }, 60000);
+
+  await new Promise(resolve => setTimeout(resolve, delayMs));
+  clearInterval(timer);
+};
+
+export const resolveConfiguredFallbackModel = ({ tool, currentModel, configuredFallbackModel = undefined } = {}) => {
+  if (configuredFallbackModel) return configuredFallbackModel;
+  return resolveDefaultFallbackModel(tool, currentModel);
+};
+
+export const maybeSwitchToFallbackModel = async ({ tool, argv, log, errorMessage } = {}) => {
+  const fallbackModel = resolveConfiguredFallbackModel({
+    tool,
+    currentModel: argv?.model,
+    configuredFallbackModel: argv?.fallbackModel,
+  });
+
+  const classification = classifyRetryableError(errorMessage);
+  if (!fallbackModel || !classification.isCapacity || !argv?.model) {
+    return { switched: false, fallbackModel, reason: classification.label };
+  }
+
+  const currentResolvedModel = normalizeModelKey(resolveModelId(argv.model, tool));
+  const fallbackResolvedModel = normalizeModelKey(resolveModelId(fallbackModel, tool));
+  if (!fallbackResolvedModel || currentResolvedModel === fallbackResolvedModel) {
+    return { switched: false, fallbackModel, reason: classification.label };
+  }
+
+  const previousModel = argv.model;
+  argv.model = fallbackModel;
+  if (!argv.fallbackModel) argv.fallbackModel = fallbackModel;
+
+  if (typeof log === 'function') {
+    await log(`🔀 Switching to fallback model: ${previousModel} -> ${fallbackModel}`, { level: 'warning' });
+  }
+
+  return {
+    switched: true,
+    fallbackModel,
+    previousModel,
+    reason: classification.label,
+  };
+};
+
+export default {
+  classifyRetryableError,
+  getRetryDelayMs,
+  waitWithCountdown,
+  resolveConfiguredFallbackModel,
+  maybeSwitchToFallbackModel,
+};