@link-assistant/hive-mind 0.39.0

package/src/telegram-markdown.lib.mjs

@@ -0,0 +1,64 @@
+/**
+ * Telegram markdown escaping utilities
+ * @module telegram-markdown.lib
+ */
+
+/**
+ * Escape special characters for Telegram's basic Markdown parser.
+ * Only escapes underscore and asterisk to prevent parsing errors.
+ * @param {string} text - Text to escape
+ * @returns {string} Escaped text safe for Markdown parse_mode
+ */
+export function escapeMarkdown(text) {
+  if (!text || typeof text !== 'string') {
+    return text;
+  }
+  // Escape underscore and asterisk which are the most common issues in URLs
+  // These can cause "Can't find end of entity" errors when Telegram tries to parse them
+  return text.replace(/_/g, '\\_').replace(/\*/g, '\\*');
+}
+
+/**
+ * Escape special characters for Telegram's MarkdownV2 parser.
+ * According to Telegram Bot API, these characters must be escaped in MarkdownV2:
+ * _ * [ ] ( ) ~ ` > # + - = | { } . ! \
+ * @param {string} text - Text to escape
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.preserveCodeBlocks - If true, preserves inline code blocks (text between backticks) without escaping. Default: false
+ * @returns {string} Escaped text safe for MarkdownV2 parse_mode
+ */
+export function escapeMarkdownV2(text, options = {}) {
+  if (!text || typeof text !== 'string') return text;
+
+  const { preserveCodeBlocks = false } = options;
+
+  // If not preserving code blocks, escape everything including backticks
+  if (!preserveCodeBlocks) {
+    return text.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1');
+  }
+
+  // Split text into parts: inline code blocks and regular text
+  const parts = [];
+  let lastIndex = 0;
+  const codeBlockRegex = /`[^`]+`/g;
+  let match;
+
+  while ((match = codeBlockRegex.exec(text)) !== null) {
+    // Add escaped regular text before code block
+    if (match.index > lastIndex) {
+      const regularText = text.substring(lastIndex, match.index);
+      parts.push(regularText.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1'));
+    }
+    // Add unescaped code block
+    parts.push(match[0]);
+    lastIndex = match.index + match[0].length;
+  }
+
+  // Add remaining text after last code block
+  if (lastIndex < text.length) {
+    const regularText = text.substring(lastIndex);
+    parts.push(regularText.replace(/([_*[\]()~`>#+\-=|{}.!\\])/g, '\\$1'));
+  }
+
+  return parts.join('');
+}

package/src/usage-limit.lib.mjs

@@ -0,0 +1,218 @@
+/**
+ * Usage Limit Detection Utilities
+ *
+ * This module provides utilities for detecting and handling usage limit errors
+ * from AI tools (Claude, Codex, OpenCode).
+ *
+ * Related issue: https://github.com/link-assistant/hive-mind/issues/719
+ */
+
+/**
+ * Detect if an error message indicates a usage limit has been reached
+ *
+ * @param {string} message - Error message to analyze
+ * @returns {boolean} - True if message indicates usage limit
+ */
+export function isUsageLimitError(message) {
+  if (!message || typeof message !== 'string') {
+    return false;
+  }
+
+  const lowerMessage = message.toLowerCase();
+
+  // Check for specific usage limit patterns
+  const patterns = [
+    // Generic
+    "you've hit your usage limit",
+    'hit your usage limit',
+    'you have exceeded your rate limit',
+    'usage limit reached',
+    'usage limit exceeded',
+    'rate_limit_exceeded',
+    'rate limit exceeded',
+    'limit reached',
+    'limit has been reached',
+    // Provider-specific phrasings we’ve seen in the wild
+    'session limit reached', // Claude
+    'weekly limit reached',  // Claude
+    'daily limit reached',
+    'monthly limit reached',
+    'billing hard limit',
+    'please try again at',   // Codex/OpenCode style
+    'available again at',
+    'resets'                 // Claude shows: “∙ resets 5am”
+  ];
+
+  return patterns.some(pattern => lowerMessage.includes(pattern));
+}
+
+/**
+ * Extract reset time from usage limit error message
+ *
+ * @param {string} message - Error message to analyze
+ * @returns {string|null} - Reset time string (e.g., "12:16 PM") or null if not found
+ */
+export function extractResetTime(message) {
+  if (!message || typeof message !== 'string') {
+    return null;
+  }
+
+  // Normalize whitespace for easier matching
+  const normalized = message.replace(/\s+/g, ' ');
+
+  // Pattern 1: "try again at 12:16 PM"
+  const tryAgainMatch = normalized.match(/try again at ([0-9]{1,2}:[0-9]{2}\s*[AP]M)/i);
+  if (tryAgainMatch) {
+    return tryAgainMatch[1];
+  }
+
+  // Pattern 2: "available at 12:16 PM"
+  const availableMatch = normalized.match(/available at ([0-9]{1,2}:[0-9]{2}\s*[AP]M)/i);
+  if (availableMatch) {
+    return availableMatch[1];
+  }
+
+  // Pattern 3: "reset at 12:16 PM"
+  const resetMatch = normalized.match(/reset at ([0-9]{1,2}:[0-9]{2}\s*[AP]M)/i);
+  if (resetMatch) {
+    return resetMatch[1];
+  }
+
+  // Pattern 4: Claude-style: "resets 5am" or "resets at 5am" (no minutes)
+  const resetsAmPmNoMinutes = normalized.match(/resets(?:\s+at)?\s+([0-9]{1,2})\s*([AP]M)/i);
+  if (resetsAmPmNoMinutes) {
+    const hour = resetsAmPmNoMinutes[1];
+    const ampm = resetsAmPmNoMinutes[2].toUpperCase();
+    return `${hour}:00 ${ampm}`;
+  }
+
+  // Pattern 5: Claude-style with minutes: "resets 5:00am" or "resets at 5:00 am"
+  const resetsAmPmWithMinutes = normalized.match(/resets(?:\s+at)?\s+([0-9]{1,2}:[0-9]{2})\s*([AP]M)/i);
+  if (resetsAmPmWithMinutes) {
+    const time = resetsAmPmWithMinutes[1];
+    const ampm = resetsAmPmWithMinutes[2].toUpperCase();
+    return `${time} ${ampm}`;
+  }
+
+  // Pattern 6: 24-hour time: "resets 17:00" or "resets at 05:00"
+  const resets24h = normalized.match(/resets(?:\s+at)?\s+([0-2]?[0-9]):([0-5][0-9])\b/i);
+  if (resets24h) {
+    let hour = parseInt(resets24h[1], 10);
+    const minute = resets24h[2];
+    const ampm = hour >= 12 ? 'PM' : 'AM';
+    if (hour === 0) hour = 12; // 0 -> 12 AM
+    else if (hour > 12) hour -= 12; // 13-23 -> 1-11 PM
+    return `${hour}:${minute} ${ampm}`;
+  }
+
+  // Pattern 7: "resets 5am" written without space (already partially covered) – ensure we catch compact forms
+  const resetsCompact = normalized.match(/resets(?:\s+at)?\s*([0-9]{1,2})(?::([0-9]{2}))?\s*([ap]m)/i);
+  if (resetsCompact) {
+    const hour = resetsCompact[1];
+    const minute = resetsCompact[2] || '00';
+    const ampm = resetsCompact[3].toUpperCase();
+    return `${hour}:${minute} ${ampm}`;
+  }
+
+  // Pattern 8: standalone time like "12:16 PM" (less reliable, so last)
+  const timeMatch = normalized.match(/\b([0-9]{1,2}:[0-9]{2}\s*[AP]M)\b/i);
+  if (timeMatch) {
+    // Normalize spacing in AM/PM
+    const t = timeMatch[1].replace(/\s*([AP]M)/i, ' $1');
+    return t;
+  }
+
+  return null;
+}
+
+/**
+ * Detect usage limit error and extract all relevant information
+ *
+ * @param {string} message - Error message to analyze
+ * @returns {Object} - { isUsageLimit: boolean, resetTime: string|null }
+ */
+export function detectUsageLimit(message) {
+  const isUsageLimit = isUsageLimitError(message);
+  const resetTime = isUsageLimit ? extractResetTime(message) : null;
+
+  return {
+    isUsageLimit,
+    resetTime
+  };
+}
+
+/**
+ * Format usage limit error message for console output
+ *
+ * @param {Object} options - Formatting options
+ * @param {string} options.tool - Tool name (claude, codex, opencode)
+ * @param {string|null} options.resetTime - Time when limit resets
+ * @param {string|null} options.sessionId - Session ID for resuming
+ * @param {string|null} options.resumeCommand - Command to resume session
+ * @returns {string[]} - Array of formatted message lines
+ */
+export function formatUsageLimitMessage({ tool, resetTime, sessionId, resumeCommand }) {
+  const lines = [
+    '',
+    '⏳ Usage Limit Reached!',
+    '',
+    `Your ${tool || 'AI tool'} usage limit has been reached.`
+  ];
+
+  if (resetTime) {
+    lines.push(`The limit will reset at: ${resetTime}`);
+  } else {
+    lines.push('Please wait for the limit to reset.');
+  }
+
+  if (sessionId && resumeCommand) {
+    lines.push('');
+    lines.push(`📌 Session ID: ${sessionId}`);
+    lines.push('');
+    lines.push('To resume this session after the limit resets, run:');
+    lines.push(`   ${resumeCommand}`);
+  }
+
+  lines.push('');
+
+  return lines;
+}
+
+/**
+ * Check if a message contains both usage limit error and is in JSON format
+ * Useful for parsing structured error responses
+ *
+ * @param {string} line - Line to check
+ * @returns {Object|null} - Parsed JSON object if valid, null otherwise
+ */
+export function parseUsageLimitJson(line) {
+  try {
+    const data = JSON.parse(line);
+
+    // Check for error in JSON
+    if (data.type === 'error' && data.message) {
+      if (isUsageLimitError(data.message)) {
+        return {
+          type: 'error',
+          message: data.message,
+          limitInfo: detectUsageLimit(data.message)
+        };
+      }
+    }
+
+    // Check for turn.failed with error
+    if (data.type === 'turn.failed' && data.error && data.error.message) {
+      if (isUsageLimitError(data.error.message)) {
+        return {
+          type: 'turn.failed',
+          message: data.error.message,
+          limitInfo: detectUsageLimit(data.error.message)
+        };
+      }
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/version.lib.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { readFile, access } from 'fs/promises';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { getGitVersion } from './git.lib.mjs';
+
+async function isRunningAsScript() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const gitDir = join(__dirname, '..', '.git');
+  try {
+    await access(gitDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function getVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const packagePath = join(__dirname, '..', 'package.json');
+
+  try {
+    const packageJsonContent = await readFile(packagePath, 'utf8');
+    const packageJson = JSON.parse(packageJsonContent);
+    const currentVersion = packageJson.version;
+
+    if (await isRunningAsScript()) {
+      const version = await getGitVersion(undefined, currentVersion);
+      return version;
+    }
+
+    return currentVersion;
+  } catch {
+    return 'unknown';
+  }
+}
+
+export default { getVersion };

package/src/youtrack/solve.youtrack.lib.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+/**
+ * YouTrack integration module for solve.mjs
+ * Handles YouTrack URL validation, configuration, and issue updates
+ */
+
+// Import YouTrack-related functions
+const youTrackLib = await import('./youtrack.lib.mjs');
+const {
+  parseYouTrackIssueId,
+  updateYouTrackIssueStage,
+  addYouTrackComment,
+  createYouTrackConfigFromEnv
+} = youTrackLib;
+
+/**
+ * Validates YouTrack URLs and extracts issue information
+ * @param {string} issueUrl - The URL or issue ID to validate
+ * @returns {Object} Validation result with YouTrack info
+ */
+export async function validateYouTrackUrl(issueUrl) {
+  let isYouTrackUrl = null;
+  let youTrackIssueId = null;
+  let youTrackConfig = null;
+
+  if (!issueUrl) {
+    return { isYouTrackUrl: false, youTrackIssueId: null, youTrackConfig: null };
+  }
+
+  // Check for YouTrack issue format (youtrack://PROJECT-123 or youtrack://2-123)
+  isYouTrackUrl = issueUrl.match(/^youtrack:\/\/([A-Z0-9]+-\d+)$/i);
+
+  // Also check if it's a direct YouTrack issue ID
+  if (!isYouTrackUrl) {
+    youTrackIssueId = parseYouTrackIssueId(issueUrl);
+    if (youTrackIssueId) {
+      isYouTrackUrl = [issueUrl, youTrackIssueId];
+    }
+  } else {
+    youTrackIssueId = isYouTrackUrl[1];
+  }
+
+  // If YouTrack URL detected, set up YouTrack configuration
+  if (isYouTrackUrl) {
+    youTrackConfig = createYouTrackConfigFromEnv();
+    if (!youTrackConfig) {
+      console.error('Error: YouTrack URL detected but YouTrack configuration not found');
+      console.error('  Required environment variables:');
+      console.error('    YOUTRACK_URL - Your YouTrack instance URL');
+      console.error('    YOUTRACK_API_KEY - Your YouTrack API token');
+      console.error('    YOUTRACK_PROJECT_CODE - Project code (e.g., PAG)');
+      console.error('    YOUTRACK_STAGE - Current stage field value');
+      console.error('  Optional:');
+      console.error('    YOUTRACK_NEXT_STAGE - Stage to move issue to after PR creation');
+      process.exit(1);
+    }
+  }
+
+  return {
+    isYouTrackUrl: !!isYouTrackUrl,
+    youTrackIssueId,
+    youTrackConfig
+  };
+}
+
+/**
+ * Updates YouTrack issue with PR information and stage changes
+ * @param {string} youTrackIssueId - The YouTrack issue ID
+ * @param {Object} youTrackConfig - YouTrack configuration
+ * @param {string} prUrl - Pull request URL
+ * @param {Function} log - Logging function
+ */
+export async function updateYouTrackIssue(youTrackIssueId, youTrackConfig, prUrl, log) {
+  if (!youTrackIssueId || !youTrackConfig || !prUrl) {
+    return;
+  }
+
+  await log(`\n🔗 Updating YouTrack issue ${youTrackIssueId}...`);
+
+  // Add comment about PR
+  const prComment = `Pull Request created: ${prUrl}\n\nPlease review the proposed solution.`;
+  const commentAdded = await addYouTrackComment(youTrackIssueId, prComment, youTrackConfig);
+  if (commentAdded) {
+    await log('✅ Added comment to YouTrack issue');
+  } else {
+    await log('⚠️ Failed to add comment to YouTrack issue', { level: 'warning' });
+  }
+
+  // Update issue stage if nextStage is configured
+  if (youTrackConfig.nextStage) {
+    const stageUpdated = await updateYouTrackIssueStage(youTrackIssueId, youTrackConfig.nextStage, youTrackConfig);
+    if (stageUpdated) {
+      await log(`✅ Updated YouTrack issue stage to "${youTrackConfig.nextStage}"`);
+    } else {
+      await log('⚠️ Failed to update YouTrack issue stage', { level: 'warning' });
+    }
+  }
+}
+
+/**
+ * Checks if a URL format could be a YouTrack URL
+ * @param {string} url - URL to check
+ * @returns {boolean} True if it matches YouTrack patterns
+ */
+export function isYouTrackFormat(url) {
+  if (!url) return false;
+
+  // Check for youtrack:// format
+  if (url.match(/^youtrack:\/\//)) return true;
+
+  // Check for direct issue ID format (PROJECT-123 or 2-123)
+  if (url.match(/^[A-Z0-9]+-\d+$/i)) return true;
+
+  return false;
+}

package/src/youtrack/youtrack-sync.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+
+/**
+ * YouTrack to GitHub Issue Synchronization Module
+ *
+ * This module syncs YouTrack issues to GitHub, creating GitHub issues that:
+ * - Include the YouTrack ID in the title for automatic linking
+ * - Can be processed by solve.mjs normally
+ * - Result in PRs that YouTrack will automatically link back
+ */
+
+// Import YouTrack functions
+const youTrackLib = await import('./youtrack.lib.mjs');
+const {
+  fetchYouTrackIssues
+} = youTrackLib;
+
+/**
+ * Find existing GitHub issue for a YouTrack issue
+ * @param {string} youTrackId - The YouTrack issue ID (e.g., "2-3606")
+ * @param {string} owner - GitHub repository owner
+ * @param {string} repo - GitHub repository name
+ * @param {Object} $ - Command execution function
+ * @returns {Object|null} GitHub issue if found
+ */
+export async function findGitHubIssueForYouTrack(youTrackId, owner, repo, $) {
+  try {
+    // Search for both open and closed issues with the YouTrack ID in the title
+    // This prevents creating duplicates even if an issue was closed
+    const searchResult = await $`gh api search/issues --jq '.items' -X GET -f q="repo:${owner}/${repo} \"${youTrackId}\" in:title is:issue"`;
+
+    if (searchResult.code !== 0) {
+      return null;
+    }
+
+    const issues = JSON.parse(searchResult.stdout.toString().trim() || '[]');
+
+    // Find exact match (YouTrack ID should be in brackets or at start)
+    // Return the first matching issue (prefer open issues)
+    const openIssue = issues.find(issue =>
+      issue.state === 'open' && (issue.title.includes(`[${youTrackId}]`) || issue.title.startsWith(`${youTrackId}:`))
+    );
+
+    if (openIssue) return openIssue;
+
+    // If no open issue, check for closed issues to prevent duplicates
+    const closedIssue = issues.find(issue =>
+      issue.state === 'closed' && (issue.title.includes(`[${youTrackId}]`) || issue.title.startsWith(`${youTrackId}:`))
+    );
+
+    return closedIssue || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Create or update GitHub issue from YouTrack issue
+ * @param {Object} youTrackIssue - YouTrack issue object
+ * @param {string} owner - GitHub repository owner
+ * @param {string} repo - GitHub repository name
+ * @param {Object} youTrackConfig - YouTrack configuration
+ * @param {Object} $ - Command execution function
+ * @param {Function} log - Logging function
+ * @returns {Object} Created or updated GitHub issue
+ */
+export async function syncYouTrackIssueToGitHub(youTrackIssue, owner, repo, youTrackConfig, $, log) {
+  const youTrackId = youTrackIssue.id;
+  const youTrackUrl = youTrackIssue.url || `${youTrackConfig.url}/issue/${youTrackId}`;
+
+  // Format title with YouTrack ID for automatic linking
+  // Format: "[PROJECT-123] Original Title" or "PROJECT-123: Original Title"
+  const ghTitle = `[${youTrackId}] ${youTrackIssue.summary}`;
+
+  // Build issue body with YouTrack details
+  const ghBody = `## YouTrack Issue
+
+**ID:** ${youTrackId}
+**Link:** ${youTrackUrl}
+**Stage:** ${youTrackIssue.customFields?.find(f => f.name === 'Stage')?.value?.name || 'Unknown'}
+
+## Description
+
+${youTrackIssue.description || 'No description provided.'}
+
+---
+*This issue is automatically synchronized from YouTrack. Any commits or PRs that reference \`${youTrackId}\` will be automatically linked in YouTrack.*
+
+**Note:** To process this issue, ensure the 'help wanted' label exists in your repository.`;
+
+  // Check if issue already exists
+  const existingIssue = await findGitHubIssueForYouTrack(youTrackId, owner, repo, $);
+
+  if (existingIssue) {
+    // If issue is closed, skip it (don't recreate or update)
+    if (existingIssue.state === 'closed') {
+      await log(`   ⏭️ Skipping ${youTrackId} - GitHub issue #${existingIssue.number} is closed`);
+      return existingIssue;
+    }
+
+    // Update existing open issue if title or body changed
+    const needsUpdate = existingIssue.title !== ghTitle || existingIssue.body !== ghBody;
+
+    if (needsUpdate) {
+      await log(`   📝 Updating issue #${existingIssue.number} for ${youTrackId}...`);
+
+      const updateResult = await $`gh issue edit ${existingIssue.number} --repo ${owner}/${repo} --title "${ghTitle}" --body "${ghBody}"`;
+
+      if (updateResult.code === 0) {
+        await log(`   ✅ Updated issue #${existingIssue.number}`);
+      } else {
+        await log(`   ⚠️ Failed to update issue #${existingIssue.number}`, { level: 'warning' });
+      }
+    } else {
+      await log(`   ✓ Issue #${existingIssue.number} already up to date for ${youTrackId}`);
+    }
+
+    // Ensure help wanted label is applied
+    const hasLabel = existingIssue.labels?.some(l => l.name === 'help wanted');
+    if (!hasLabel) {
+      try {
+        await $`gh issue edit ${existingIssue.number} --repo ${owner}/${repo} --add-label "help wanted"`;
+        await log(`   🏷️ Added 'help wanted' label to #${existingIssue.number}`);
+      } catch {
+        // Silently skip if label doesn't exist
+        await log('   ⚠️ Could not add \'help wanted\' label (may not exist in repo)', { verbose: true });
+      }
+    }
+
+    return existingIssue;
+  } else {
+    // Create new issue
+    await log(`   ➕ Creating GitHub issue for ${youTrackId}...`);
+
+    try {
+      const createResult = await $`gh issue create --repo ${owner}/${repo} --title "${ghTitle}" --body "${ghBody}" --label "help wanted"`;
+
+      if (createResult.code === 0) {
+        const issueUrl = createResult.stdout.toString().trim();
+        const issueNumber = issueUrl.match(/\/issues\/(\d+)/)?.[1];
+        await log(`   ✅ Created issue #${issueNumber} for ${youTrackId}`);
+        await log(`   📍 URL: ${issueUrl}`);
+
+        return {
+          number: issueNumber,
+          title: ghTitle,
+          body: ghBody,
+          html_url: issueUrl
+        };
+      } else {
+        await log(`   ❌ Failed to create issue for ${youTrackId}`, { level: 'error' });
+        return null;
+      }
+    } catch (error) {
+      await log(`   ❌ Error creating issue: ${error.message}`, { level: 'error' });
+      return null;
+    }
+  }
+}
+
+/**
+ * Sync all YouTrack issues to GitHub
+ * @param {Object} youTrackConfig - YouTrack configuration
+ * @param {string} owner - GitHub repository owner
+ * @param {string} repo - GitHub repository name
+ * @param {Object} $ - Command execution function
+ * @param {Function} log - Logging function
+ * @returns {Array} Array of GitHub issues (created or updated)
+ */
+export async function syncYouTrackToGitHub(youTrackConfig, owner, repo, $, log) {
+  await log('\n🔄 Syncing YouTrack issues to GitHub...');
+  await log(`   📍 YouTrack: ${youTrackConfig.url}`);
+  await log(`   📋 Project: ${youTrackConfig.projectCode}`);
+  await log(`   📌 Stage: "${youTrackConfig.stage}"`);
+  await log(`   🎯 Target: ${owner}/${repo}`);
+
+  // Fetch YouTrack issues
+  const youTrackIssues = await fetchYouTrackIssues(youTrackConfig);
+
+  if (!youTrackIssues || youTrackIssues.length === 0) {
+    await log(`   ℹ️ No issues found in YouTrack with stage "${youTrackConfig.stage}"`);
+    return [];
+  }
+
+  await log(`   📊 Found ${youTrackIssues.length} issue(s) to sync`);
+
+  // Sync each issue to GitHub
+  const githubIssues = [];
+  for (const ytIssue of youTrackIssues) {
+    const ghIssue = await syncYouTrackIssueToGitHub(ytIssue, owner, repo, youTrackConfig, $, log);
+    if (ghIssue) {
+      githubIssues.push({
+        ...ghIssue,
+        youtrackId: ytIssue.id,
+        youtrackUrl: `${youTrackConfig.url}/issue/${ytIssue.idReadable}`
+      });
+    }
+  }
+
+  await log(`   ✅ Sync complete: ${githubIssues.length} issues ready in GitHub`);
+
+  return githubIssues;
+}
+
+/**
+ * Convert synced GitHub issues to format expected by hive.mjs
+ * @param {Array} githubIssues - Array of GitHub issues with YouTrack metadata
+ * @returns {Array} Issues in hive.mjs format
+ */
+export function formatIssuesForHive(githubIssues) {
+  return githubIssues.map(issue => ({
+    number: issue.number,
+    title: issue.title,
+    html_url: issue.html_url,
+    labels: issue.labels || [{ name: 'help-wanted' }],
+    youtrackId: issue.youtrackId,
+    youtrackUrl: issue.youtrackUrl
+  }));
+}