@link-assistant/hive-mind 1.35.8 → 1.35.10

package/src/opencode.lib.mjs

@@ -18,27 +18,16 @@ import { reportError } from './sentry.lib.mjs';
 import { timeouts } from './config.lib.mjs';
 import { detectUsageLimit, formatUsageLimitMessage } from './usage-limit.lib.mjs';
 import { sanitizeObjectStrings } from './unicode-sanitization.lib.mjs';
+import { opencodeModels, defaultModels } from './models/index.mjs';
 
 // Model mapping to translate aliases to full model IDs for OpenCode
+// Issue #1473: Uses centralized opencodeModels from models/index.mjs (single source of truth)
 export const mapModelToId = model => {
-  const modelMap = {
-    gpt4: 'openai/gpt-4',
-    gpt4o: 'openai/gpt-4o',
-    claude: 'anthropic/claude-3-5-sonnet',
-    sonnet: 'anthropic/claude-3-5-sonnet',
-    opus: 'anthropic/claude-3-opus',
-    gemini: 'google/gemini-pro',
-    grok: 'opencode/grok-code',
-    'grok-code': 'opencode/grok-code',
-    'grok-code-fast-1': 'opencode/grok-code',
-  };
-
-  // Return mapped model ID if it's an alias, otherwise return as-is
-  return modelMap[model] || model;
+  return opencodeModels[model] || model;
 };
 
 // Function to validate OpenCode connection
-export const validateOpenCodeConnection = async (model = 'grok-code-fast-1') => {
+export const validateOpenCodeConnection = async (model = defaultModels.opencode) => {
   // Map model alias to full ID
   const mappedModel = mapModelToId(model);
 

package/src/review.mjs

@@ -49,6 +49,7 @@ import * as memoryCheck from './memory-check.mjs';
 
 // Import Claude execution functions
 import { executeClaudeCommand } from './claude.lib.mjs';
+import { defaultModels, getClaudeModelChoices, buildModelOptionDescription } from './models/index.mjs';
 
 // Configure command line arguments - GitHub PR URL as positional argument
 // Use yargs().parse(args) instead of yargs(args).argv to ensure .strict() mode works
@@ -70,10 +71,10 @@ const argv = yargs()
   })
   .option('model', {
     type: 'string',
-    description: 'Model to use (opus, sonnet, or full model ID like claude-sonnet-4-5-20250929)',
+    description: buildModelOptionDescription(),
     alias: 'm',
-    default: 'opus',
-    choices: ['opus', 'sonnet', 'claude-sonnet-4-5-20250929', 'claude-opus-4-6', 'claude-opus-4-5-20251101'],
+    default: defaultModels.claude,
+    choices: getClaudeModelChoices(),
   })
   .option('focus', {
     type: 'string',

package/src/solve.config.lib.mjs

@@ -8,6 +8,7 @@
 // This approach was adopted per issue #482 feedback to minimize custom code maintenance
 
 import { enhanceErrorMessage, detectMalformedFlags } from './option-suggestions.lib.mjs';
+import { defaultModels, buildModelOptionDescription } from './models/index.mjs';
 
 // Re-export for use by telegram-bot.mjs (avoids extra import lines there)
 export { detectMalformedFlags };
@@ -428,18 +429,11 @@ export const createYargsConfig = yargsInstance => {
   config = config
     .option('model', {
       type: 'string',
-      description: 'Model to use (for claude: opus, sonnet, haiku, haiku-3-5, haiku-3; for opencode: grok, gpt4o; for codex: gpt5, gpt5-codex, o3; for agent: minimax-m2.5-free, big-pickle, gpt-5-nano, glm-5-free, deepseek-r1-free)',
+      description: buildModelOptionDescription(),
       alias: 'm',
       default: currentParsedArgs => {
-        // Dynamic default based on tool selection
-        if (currentParsedArgs?.tool === 'opencode') {
-          return 'grok-code-fast-1';
-        } else if (currentParsedArgs?.tool === 'codex') {
-          return 'gpt-5';
-        } else if (currentParsedArgs?.tool === 'agent') {
-          return 'minimax-m2.5-free';
-        }
-        return 'sonnet';
+        // Dynamic default based on tool selection (Issue #1473: centralized in models/index.mjs)
+        return defaultModels[currentParsedArgs?.tool] || defaultModels.claude;
       },
     })
     .parserConfiguration({
@@ -569,15 +563,10 @@ export const parseArguments = async (yargs, hideBin) => {
     }
   }
 
-  if (argv.tool === 'opencode' && !modelExplicitlyProvided) {
-    // User did not explicitly provide --model, so use the correct default for opencode
-    argv.model = 'grok-code-fast-1';
-  } else if (argv.tool === 'codex' && !modelExplicitlyProvided) {
-    // User did not explicitly provide --model, so use the correct default for codex
-    argv.model = 'gpt-5';
-  } else if (argv.tool === 'agent' && !modelExplicitlyProvided) {
-    // User did not explicitly provide --model, so use the correct default for agent
-    argv.model = 'minimax-m2.5-free';
+  if (argv.tool && !modelExplicitlyProvided && defaultModels[argv.tool]) {
+    // User did not explicitly provide --model, so use the correct default for the tool
+    // (Issue #1473: centralized in models/index.mjs)
+    argv.model = defaultModels[argv.tool];
   }
 
   // Validate mutual exclusivity of --claude-file and --gitkeep-file

package/src/solve.mjs

@@ -84,7 +84,7 @@ const { setupRepositoryAndClone, verifyDefaultBranchAndStatus } = await import('
 const { createOrCheckoutBranch } = await import('./solve.branch.lib.mjs');
 const { startWorkSession, endWorkSession, SESSION_TYPES } = await import('./solve.session.lib.mjs');
 const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions } = await import('./solve.preparation.lib.mjs');
-const { validateAndExitOnInvalidModel } = await import('./model-validation.lib.mjs');
+const { validateAndExitOnInvalidModel } = await import('./models/index.mjs');
 const { autoAcceptInviteForRepo } = await import('./solve.accept-invite.lib.mjs');
 
 // Initialize log file early (before argument parsing) to capture all output

package/src/task.mjs

@@ -41,6 +41,7 @@ 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;
@@ -106,10 +107,10 @@ const argv = yargs()
   })
   .option('model', {
     type: 'string',
-    description: 'Model to use (opus, sonnet, or full model ID like claude-sonnet-4-5-20250929)',
+    description: buildModelOptionDescription(),
     alias: 'm',
-    default: 'sonnet',
-    choices: ['opus', 'sonnet', 'claude-sonnet-4-5-20250929', 'claude-opus-4-6', 'claude-opus-4-5-20251101'],
+    default: defaultModels.claude,
+    choices: Object.keys(claudeModels),
   })
   .option('verbose', {
     type: 'boolean',

package/src/telegram-bot.mjs

@@ -47,7 +47,7 @@ const hideBin = _helpersBot.hideBin || (argv => argv.slice(2));
 const { createYargsConfig: createSolveYargsConfig, detectMalformedFlags } = await import('./solve.config.lib.mjs');
 const { createYargsConfig: createHiveYargsConfig } = await import('./hive.config.lib.mjs');
 const { parseGitHubUrl } = await import('./github.lib.mjs');
-const { validateModelName } = await import('./model-validation.lib.mjs');
+const { validateModelName, buildModelOptionDescription } = await import('./models/index.mjs');
 const { formatUsageMessage, getAllCachedLimits } = await import('./limits.lib.mjs');
 const { getVersionInfo, formatVersionMessage } = await import('./version-info.lib.mjs');
 const { escapeMarkdown, escapeMarkdownV2, cleanNonPrintableChars, makeSpecialCharsVisible } = await import('./telegram-markdown.lib.mjs');
@@ -659,7 +659,7 @@ bot.command('help', async ctx => {
   message += '*/help* - Show this help message\n\n';
   message += '⚠️ *Note:* /solve, /hive, /solve\\_queue, /limits, /version, /accept\\_invites and /merge commands only work in group chats.\n\n';
   message += '🔧 *Common Options:*\n';
-  message += '• `--model <model>` or `-m` - Specify AI model (sonnet, opus, haiku, haiku-3-5, haiku-3)\n';
+  message += `• \`--model <model>\` or \`-m\` - ${buildModelOptionDescription()}\n`;
   message += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
   message += '• `--think <level>` - Thinking level (off/low/medium/high/max) | `--thinking-budget <num>` - Token budget (0-63999)\n';
   message += '• `--verbose` or `-v` - Verbose output | `--attach-logs` - Attach logs to PR\n';

package/src/model-info.lib.mjs

@@ -1,360 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Model information library for hive-mind
- * Provides unified model display, verification, and metadata fetching
- * for all tools (Claude, Agent, OpenCode, Codex).
- *
- * @see https://github.com/link-assistant/hive-mind/issues/1225
- */
-
-// Check if use is already defined (when imported from solve.mjs)
-// If not, fetch it (when running standalone)
-if (typeof globalThis.use === 'undefined') {
-  globalThis.use = (await eval(await (await fetch('https://unpkg.com/use-m/use.js')).text())).use;
-}
-
-import { log } from './lib.mjs';
-
-/**
- * Map tool identifier to user-friendly display name.
- * Replaces duplicated ternary chains across the codebase.
- * @param {string|null} tool - The tool identifier (claude, codex, opencode, agent)
- * @returns {string} User-friendly display name
- */
-export const getToolDisplayName = tool => {
-  const name = (tool || '').toString().toLowerCase();
-  switch (name) {
-    case 'claude':
-      return 'Claude';
-    case 'codex':
-      return 'Codex';
-    case 'opencode':
-      return 'OpenCode';
-    case 'agent':
-      return 'Agent';
-    default:
-      return 'AI tool';
-  }
-};
-
-/**
- * Cached models.dev API response to avoid repeated network requests.
- * The cache is per-process and cleared when the process exits.
- */
-let modelsDevCache = null;
-
-/**
- * Fetch the full models.dev API data with caching.
- * @returns {Promise<Object|null>} The full API response or null on failure
- */
-const fetchModelsDevApi = async () => {
-  if (modelsDevCache) return modelsDevCache;
-  try {
-    const https = (await globalThis.use('https')).default;
-    return new Promise((resolve, reject) => {
-      https
-        .get('https://models.dev/api.json', res => {
-          let data = '';
-          res.on('data', chunk => {
-            data += chunk;
-          });
-          res.on('end', () => {
-            try {
-              modelsDevCache = JSON.parse(data);
-              resolve(modelsDevCache);
-            } catch (parseError) {
-              reject(parseError);
-            }
-          });
-        })
-        .on('error', err => {
-          reject(err);
-        });
-    });
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Fetch model metadata from models.dev API.
- * Returns enriched model information including name, provider, version, and knowledge cutoff.
- * @param {string} modelId - The model ID (e.g., "claude-opus-4-6", "opencode/grok-code")
- * @returns {Promise<Object|null>} Model metadata or null if not found
- */
-export const fetchModelInfoForComment = async modelId => {
-  if (!modelId) return null;
-  try {
-    const apiData = await fetchModelsDevApi();
-    if (!apiData) return null;
-
-    // Normalize model ID: strip provider prefix for lookup (e.g., "anthropic/claude-3-5-sonnet" -> "claude-3-5-sonnet")
-    const lookupId = modelId.includes('/') ? modelId.split('/').pop() : modelId;
-
-    // Check Anthropic provider first (most common for Claude tools)
-    if (apiData.anthropic?.models?.[lookupId]) {
-      const modelInfo = { ...apiData.anthropic.models[lookupId] };
-      modelInfo.provider = apiData.anthropic.name || 'Anthropic';
-      return modelInfo;
-    }
-
-    // Search across all providers
-    for (const provider of Object.values(apiData)) {
-      if (provider.models && provider.models[lookupId]) {
-        const modelInfo = { ...provider.models[lookupId] };
-        modelInfo.provider = provider.name || provider.id;
-        return modelInfo;
-      }
-    }
-
-    // Try the full modelId (with provider prefix) as well
-    if (lookupId !== modelId) {
-      for (const provider of Object.values(apiData)) {
-        if (provider.models && provider.models[modelId]) {
-          const modelInfo = { ...provider.models[modelId] };
-          modelInfo.provider = provider.name || provider.id;
-          return modelInfo;
-        }
-      }
-    }
-
-    return null;
-  } catch {
-    return null;
-  }
-};
-
-/**
- * Normalize model ID for comparison purposes (strip suffixes, lowercase).
- * @param {string} modelId - A model ID or alias
- * @returns {string} Normalized ID
- */
-const normalizeForComparison = modelId => {
-  if (!modelId) return '';
-  return modelId
-    .toLowerCase()
-    .replace(/\[1m\]$/i, '')
-    .trim();
-};
-
-/**
- * Check if a requested model alias matches an actual model ID.
- * @param {string} requestedModel - The --model flag value (alias or full ID)
- * @param {string} actualModelId - The actual model ID from CLI output
- * @param {string|null} tool - The tool being used
- * @returns {boolean}
- */
-const doesRequestedMatchActual = (requestedModel, actualModelId, tool) => {
-  if (!requestedModel || !actualModelId) return false;
-  const resolvedRequested = resolveModelId(requestedModel, tool);
-  const normResolved = normalizeForComparison(resolvedRequested);
-  const normActual = normalizeForComparison(actualModelId);
-  // Direct match
-  if (normResolved === normActual) return true;
-  // Partial match: resolved starts with actual or vice versa (for date-suffixed IDs)
-  if (normActual.startsWith(normResolved) || normResolved.startsWith(normActual)) return true;
-  return false;
-};
-
-/**
- * Build model information string for PR/issue comments.
- * Displays the requested model vs actual models used from CLI JSON output.
- * The main model is bolded if it matches the requested model.
- * A warning is shown if the main model doesn't match the requested model.
- *
- * @param {Object} options - Model info options
- * @param {string|null} options.requestedModel - The model requested via --model flag (e.g., "opus")
- * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex)
- * @param {Object|null} options.pricingInfo - Pricing info from tool result (agent tool provides modelId)
- * @param {Object|null} options.modelInfo - Pre-fetched model metadata from models.dev (for first actual model)
- * @param {Array<{modelId: string, modelInfo: Object|null}>|null} options.modelsUsed - Actual models used from CLI JSON output
- * @returns {string} Formatted markdown string for model info section (empty if no data available)
- */
-export const buildModelInfoString = ({ requestedModel = null, tool = null, pricingInfo = null, modelInfo = null, modelsUsed = null } = {}) => {
-  const hasRequested = requestedModel !== null && requestedModel !== undefined;
-  const hasModelsUsed = Array.isArray(modelsUsed) && modelsUsed.length > 0;
-  const hasModelInfo = modelInfo !== null;
-  const hasPricingModel = pricingInfo?.modelId || pricingInfo?.modelName;
-
-  if (!hasRequested && !hasModelsUsed && !hasModelInfo && !hasPricingModel) return '';
-
-  let info = '\n\n### 🤖 **Models used:**';
-
-  // Display tool name
-  if (tool) {
-    info += `\n- Tool: ${getToolDisplayName(tool)}`;
-  }
-
-  // Display requested model (--model flag value)
-  if (hasRequested) {
-    info += `\n- Requested: \`${requestedModel}\``;
-  }
-
-  if (hasModelsUsed) {
-    // The first model is considered the "main" model
-    const [mainEntry, ...supportingEntries] = modelsUsed;
-    const mainModelId = mainEntry.modelId;
-    const mainModelMeta = mainEntry.modelInfo;
-
-    const mainMatches = hasRequested ? doesRequestedMatchActual(requestedModel, mainModelId, tool) : true;
-
-    // Build main model line
-    const mainModelName = mainModelMeta?.name || mainModelId;
-
-    // Use "Model" label when only one model, "Main model" when multiple
-    const modelLabel = supportingEntries.length > 0 ? 'Main model' : 'Model';
-
-    if (mainMatches) {
-      info += `\n- **${modelLabel}: ${mainModelName}** (\`${mainModelId}\`)`;
-    } else {
-      // Main model doesn't match requested - show warning
-      info += `\n- **${modelLabel}: ${mainModelName}** (\`${mainModelId}\`)`;
-      if (hasRequested) {
-        info += `\n- ⚠️ **Warning**: Main model \`${mainModelId}\` does not match requested model \`${requestedModel}\``;
-      }
-    }
-
-    // Display additional models
-    if (supportingEntries.length > 0) {
-      info += '\n- **Additional models:**';
-      for (const entry of supportingEntries) {
-        const name = entry.modelInfo?.name || entry.modelId;
-        info += `\n  *  **${name}** (\`${entry.modelId}\`)`;
-      }
-    }
-  } else if (hasModelInfo) {
-    // Fallback: single model info from models.dev (no actual CLI output data)
-    const mainModelName = modelInfo.name || (pricingInfo?.modelId ? pricingInfo.modelId : null) || 'Unknown';
-    info += `\n- Model: ${mainModelName}`;
-    if (modelInfo.id) info += ` (ID: \`${modelInfo.id}\`)`;
-    if (modelInfo.provider) info += `\n- Provider: ${modelInfo.provider}`;
-    if (modelInfo.knowledge) info += `\n- Knowledge cutoff: ${modelInfo.knowledge}`;
-  } else if (hasPricingModel) {
-    // Fallback to pricingInfo when no models.dev data
-    const modelId = pricingInfo.modelId || null;
-    const modelName = pricingInfo.modelName || modelId || 'Unknown';
-    if (modelId && modelId !== modelName) {
-      info += `\n- Model: ${modelName} (ID: \`${modelId}\`)`;
-    } else {
-      info += `\n- Model: ${modelName}`;
-    }
-    if (pricingInfo.provider) info += `\n- Provider: ${pricingInfo.provider}`;
-  }
-
-  return info;
-};
-
-/**
- * Resolve the full model ID from a user-provided alias using the model mapping.
- * @param {string|null} requestedModel - The model alias (e.g., "opus", "sonnet")
- * @param {string|null} tool - The tool being used
- * @returns {string|null} The full model ID or null
- */
-export const resolveModelId = (requestedModel, tool) => {
-  if (!requestedModel) return null;
-
-  try {
-    // Use model-mapping.lib.mjs mappings as authoritative source
-    const modelMaps = {
-      claude: {
-        sonnet: 'claude-sonnet-4-6',
-        opus: 'claude-opus-4-6',
-        haiku: 'claude-haiku-4-5-20251001',
-        'opus-4-6': 'claude-opus-4-6',
-        'opus-4-5': 'claude-opus-4-5-20251101',
-        'sonnet-4-6': 'claude-sonnet-4-6',
-        'sonnet-4-5': 'claude-sonnet-4-5-20250929',
-        'haiku-4-5': 'claude-haiku-4-5-20251001',
-      },
-      agent: {
-        grok: 'opencode/grok-code',
-        'grok-code': 'opencode/grok-code',
-        sonnet: 'anthropic/claude-3-5-sonnet',
-        opus: 'anthropic/claude-3-opus',
-        haiku: 'anthropic/claude-3-5-haiku',
-      },
-      opencode: {
-        gpt4: 'openai/gpt-4',
-        gpt4o: 'openai/gpt-4o',
-        sonnet: 'anthropic/claude-3-5-sonnet',
-        opus: 'anthropic/claude-3-opus',
-        grok: 'opencode/grok-code',
-      },
-      codex: {
-        gpt5: 'gpt-5',
-        'gpt-5': 'gpt-5',
-        o3: 'o3',
-        gpt4: 'gpt-4',
-        gpt4o: 'gpt-4o',
-        sonnet: 'claude-3-5-sonnet',
-        opus: 'claude-3-opus',
-      },
-    };
-
-    const toolName = (tool || 'claude').toString().toLowerCase();
-    const map = modelMaps[toolName];
-    if (map) {
-      // Strip [1m] suffix if present (1M context window flag)
-      const cleanModel = requestedModel.replace(/\[1m\]$/i, '');
-      return map[cleanModel.toLowerCase()] || cleanModel;
-    }
-
-    return requestedModel;
-  } catch {
-    return requestedModel;
-  }
-};
-
-/**
- * Fetch model info and build the complete model information string for PR comments.
- * Uses actual models from CLI JSON output when available.
- *
- * @param {Object} options
- * @param {string|null} options.requestedModel - The --model flag value
- * @param {string|null} options.tool - The tool used (claude, agent, opencode, codex)
- * @param {Object|null} options.pricingInfo - Pricing info from tool result
- * @param {Array<string>|null} options.actualModelIds - Actual model IDs from CLI JSON output
- *   For Claude: from tokenUsage.modelUsage keys (model IDs used in session)
- *   For Agent: from pricingInfo.modelId
- * @returns {Promise<string>} Formatted markdown model info section
- */
-export const getModelInfoForComment = async ({ requestedModel = null, tool = null, pricingInfo = null, actualModelIds = null } = {}) => {
-  // Determine the list of actual model IDs to display
-  // Priority: explicit actualModelIds > pricingInfo.modelId > resolve from requestedModel
-  let modelIds = [];
-
-  if (Array.isArray(actualModelIds) && actualModelIds.length > 0) {
-    modelIds = actualModelIds;
-  } else if (pricingInfo?.modelId) {
-    // Agent tool provides pricingInfo.modelId as the actual model used
-    modelIds = [pricingInfo.modelId];
-  } else if (requestedModel) {
-    // Fallback: resolve from requested model alias
-    const resolved = resolveModelId(requestedModel, tool);
-    if (resolved) modelIds = [resolved];
-  }
-
-  // Fetch model metadata from models.dev for each model ID
-  const modelsUsed = [];
-  for (const modelId of modelIds) {
-    let meta = null;
-    try {
-      meta = await fetchModelInfoForComment(modelId);
-    } catch {
-      await log('  ⚠️  Could not fetch model info from models.dev', { verbose: true });
-    }
-    modelsUsed.push({ modelId, modelInfo: meta });
-  }
-
-  // Determine which modelInfo to pass for legacy fallback (first model's metadata)
-  const firstModelInfo = modelsUsed.length > 0 ? modelsUsed[0].modelInfo : null;
-
-  return buildModelInfoString({
-    requestedModel,
-    tool,
-    pricingInfo,
-    modelInfo: modelsUsed.length === 0 ? firstModelInfo : null, // only used as fallback when no modelsUsed
-    modelsUsed: modelsUsed.length > 0 ? modelsUsed : null,
-  });
-};