@link-assistant/hive-mind 1.3.0 → 1.5.0

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @link-assistant/hive-mind
 
+## 1.5.0
+
+### Minor Changes
+
+- 2d41edb: Add /accept_invites command to Telegram bot for automatically accepting GitHub repository and organization invitations via gh CLI
+
+## 1.4.0
+
+### Minor Changes
+
+- 4a476ae: Add separate log comment for each auto-restart session with cost estimation
+  - Each auto-restart iteration now uploads its own session log with cost estimation to the PR
+  - Log comments use "Auto-restart X/Y Log" format instead of generic "Solution Draft Log"
+  - Issue #1107
+
+### Patch Changes
+
+- 3239fa1: Add git identity validation to prevent commit failures
+  - Added `checkGitIdentity()` and `validateGitIdentity()` functions to validate git user configuration
+  - Added git identity check to `performSystemChecks()` that runs before any work begins
+  - Added `--auto-gh-configuration-repair` option that uses external `gh-setup-git-identity` command for automatic repair
+  - Added unit tests for identity validation
+
+  This fix prevents the "fatal: empty ident name" error that occurs when git user.name and user.email are not configured. When git identity is missing, users now see a clear error message with instructions for fixing it. The auto-repair feature requires the external [gh-setup-git-identity](https://github.com/link-foundation/gh-setup-git-identity) package to be installed.
+
 ## 1.3.0
 
 ### Minor Changes

package/package.json

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

package/src/git.lib.mjs

@@ -134,6 +134,201 @@ export const getGitVersionAsync = async ($, currentVersion) => {
   return currentVersion;
 };
 
+/**
+ * Validates git user identity configuration
+ * Returns an object with validation status and identity info
+ *
+ * Git commits require both user.name and user.email to be set.
+ * This function checks both global (~/.gitconfig) and local (.git/config) configurations.
+ *
+ * See: https://git-scm.com/book/en/v2/Getting-Started-First-Time-Git-Setup
+ * Related error: "fatal: empty ident name (for <>) not allowed"
+ *
+ * @param {function} execFunc - The exec function to use (for testing)
+ * @returns {Promise<{isValid: boolean, name: string|null, email: string|null, scope: string|null, error: string|null}>}
+ */
+export const checkGitIdentity = async (execFunc = execAsync) => {
+  const result = {
+    isValid: false,
+    name: null,
+    email: null,
+    scope: null, // 'global', 'local', or 'none'
+    error: null,
+  };
+
+  try {
+    // Check for user.name
+    try {
+      const { stdout: nameStdout } = await execFunc('git config user.name', {
+        encoding: 'utf8',
+        env: process.env,
+      });
+      result.name = nameStdout.trim() || null;
+    } catch {
+      // user.name not set
+      result.name = null;
+    }
+
+    // Check for user.email
+    try {
+      const { stdout: emailStdout } = await execFunc('git config user.email', {
+        encoding: 'utf8',
+        env: process.env,
+      });
+      result.email = emailStdout.trim() || null;
+    } catch {
+      // user.email not set
+      result.email = null;
+    }
+
+    // Determine scope (check if local config exists)
+    if (result.name || result.email) {
+      try {
+        const { stdout: scopeStdout } = await execFunc('git config --show-origin user.name', {
+          encoding: 'utf8',
+          env: process.env,
+        });
+        // Output format: "file:/path/to/config\tvalue"
+        if (scopeStdout.includes('.git/config')) {
+          result.scope = 'local';
+        } else if (scopeStdout.includes('.gitconfig') || scopeStdout.includes('/etc/gitconfig')) {
+          result.scope = 'global';
+        } else {
+          result.scope = 'global';
+        }
+      } catch {
+        result.scope = 'none';
+      }
+    } else {
+      result.scope = 'none';
+    }
+
+    // Both name and email must be non-empty for valid git identity
+    // Empty string is also invalid (git rejects it)
+    result.isValid = !!(result.name && result.name.length > 0 && result.email && result.email.length > 0);
+
+    if (!result.isValid) {
+      const missing = [];
+      if (!result.name || result.name.length === 0) missing.push('user.name');
+      if (!result.email || result.email.length === 0) missing.push('user.email');
+      result.error = `Git identity incomplete: missing ${missing.join(' and ')}`;
+    }
+  } catch (error) {
+    result.error = `Failed to check git identity: ${error.message}`;
+  }
+
+  return result;
+};
+
+/**
+ * Validates git user identity and returns detailed error message if invalid
+ * Uses zx's $ for async execution
+ *
+ * @param {function} $ - The zx $ function
+ * @param {object} options - Options object
+ * @param {function} options.log - Log function for output
+ * @returns {Promise<boolean>} - True if identity is valid, false otherwise
+ */
+export const validateGitIdentity = async ($, options = {}) => {
+  const { log = console.log } = options;
+
+  // Check user.name
+  let userName = null;
+  try {
+    const nameResult = await $`git config user.name 2>/dev/null || true`;
+    userName = nameResult.stdout.toString().trim() || null;
+  } catch {
+    userName = null;
+  }
+
+  // Check user.email
+  let userEmail = null;
+  try {
+    const emailResult = await $`git config user.email 2>/dev/null || true`;
+    userEmail = emailResult.stdout.toString().trim() || null;
+  } catch {
+    userEmail = null;
+  }
+
+  // Both must be set and non-empty
+  const isValid = !!(userName && userName.length > 0 && userEmail && userEmail.length > 0);
+
+  if (!isValid) {
+    const missing = [];
+    if (!userName || userName.length === 0) missing.push('user.name');
+    if (!userEmail || userEmail.length === 0) missing.push('user.email');
+
+    await log('');
+    await log('❌ Git identity not configured', { level: 'error' });
+    await log('');
+    await log('   Git commits require both user.name and user.email to be set.');
+    await log(`   Missing: ${missing.join(' and ')}`);
+    await log('');
+    await log('   Current configuration:');
+    await log(`     user.name:  ${userName || '(not set)'}`);
+    await log(`     user.email: ${userEmail || '(not set)'}`);
+    await log('');
+    await log('   🔧 How to fix:');
+    await log('');
+    await log('   Option 1: Use GitHub CLI to set identity from your account');
+    await log('     gh-setup-git-identity');
+    await log('');
+    await log('   Option 2: Set identity manually');
+    await log('     git config --global user.name "Your Name"');
+    await log('     git config --global user.email "you@example.com"');
+    await log('');
+    await log('   Related error: "fatal: empty ident name (for <>) not allowed"');
+    await log('');
+    return false;
+  }
+
+  return true;
+};
+
+/**
+ * Attempts to repair git identity using gh-setup-git-identity --repair
+ * This function requires gh-setup-git-identity to be installed.
+ *
+ * @param {function} execFunc - The exec function to use (for testing)
+ * @returns {Promise<{success: boolean, error: string|null}>}
+ */
+export const repairGitIdentity = async (execFunc = execAsync) => {
+  const result = {
+    success: false,
+    error: null,
+  };
+
+  try {
+    // First check if gh-setup-git-identity is installed
+    try {
+      await execFunc('which gh-setup-git-identity', {
+        encoding: 'utf8',
+      });
+    } catch {
+      result.error = 'gh-setup-git-identity is not installed. Please install it first or fix git identity manually.';
+      return result;
+    }
+
+    // Run gh-setup-git-identity --repair
+    await execFunc('gh-setup-git-identity --repair', {
+      encoding: 'utf8',
+      env: process.env,
+    });
+
+    // Check if the repair was successful by validating git identity
+    const identityCheck = await checkGitIdentity(execFunc);
+    if (identityCheck.isValid) {
+      result.success = true;
+    } else {
+      result.error = `Repair command completed but identity is still invalid: ${identityCheck.error}`;
+    }
+  } catch (error) {
+    result.error = `Failed to repair git identity: ${error.message}`;
+  }
+
+  return result;
+};
+
 // Export all functions as default as well
 export default {
   isGitRepository,
@@ -142,4 +337,7 @@ export default {
   getCommitSha,
   getGitVersion,
   getGitVersionAsync,
+  checkGitIdentity,
+  validateGitIdentity,
+  repairGitIdentity,
 };

package/src/solve.config.lib.mjs

@@ -321,6 +321,11 @@ export const createYargsConfig = yargsInstance => {
         description: 'Automatically remove .playwright-mcp/ folder before checking for uncommitted changes. This prevents browser automation artifacts from triggering auto-restart. Use --no-playwright-mcp-auto-cleanup to keep the folder for debugging.',
         default: true,
       })
+      .option('auto-gh-configuration-repair', {
+        type: 'boolean',
+        description: 'Automatically repair git configuration using gh-setup-git-identity --repair when git identity is not configured. Requires gh-setup-git-identity to be installed.',
+        default: false,
+      })
       .parserConfiguration({
         'boolean-negation': true,
       })

package/src/solve.validation.lib.mjs

@@ -33,6 +33,10 @@ const {
   // isGitHubUrlType - not currently used
 } = githubLib;
 
+// Import git-related functions for identity validation and repair
+const gitLib = await import('./git.lib.mjs');
+const { checkGitIdentity, repairGitIdentity } = gitLib;
+
 // Import Claude-related functions
 const claudeLib = await import('./claude.lib.mjs');
 // Import Sentry integration
@@ -217,6 +221,77 @@ export const performSystemChecks = async (minDiskSpace = 2048, skipToolConnectio
     return false;
   }
 
+  // Check git identity configuration before proceeding
+  // This prevents the "fatal: empty ident name" error during commits
+  // See: https://github.com/link-assistant/hive-mind/issues/1131
+  let gitIdentity = await checkGitIdentity();
+  if (!gitIdentity.isValid) {
+    // Check if auto-repair is enabled
+    if (argv.autoGhConfigurationRepair) {
+      await log('');
+      await log('⚠️  Git identity not configured, attempting auto-repair...', { level: 'warning' });
+      await log(`   ${gitIdentity.error || 'Configuration is incomplete'}`);
+      await log('');
+
+      const repairResult = await repairGitIdentity();
+      if (repairResult.success) {
+        await log('✅ Git identity successfully repaired using gh-setup-git-identity --repair');
+        // Re-check identity to display the configured values
+        gitIdentity = await checkGitIdentity();
+        await log(`   user.name:  ${gitIdentity.name}`);
+        await log(`   user.email: ${gitIdentity.email}`);
+        await log('');
+      } else {
+        await log('');
+        await log('❌ Auto-repair failed', { level: 'error' });
+        await log(`   ${repairResult.error}`);
+        await log('');
+        await log('   Current configuration:');
+        await log(`     user.name:  ${gitIdentity.name || '(not set)'}`);
+        await log(`     user.email: ${gitIdentity.email || '(not set)'}`);
+        await log('');
+        await log('   🔧 How to fix manually:');
+        await log('');
+        await log('   Option 1: Install gh-setup-git-identity and use --auto-gh-configuration-repair');
+        await log('     npm install -g @link-foundation/gh-setup-git-identity');
+        await log('');
+        await log('   Option 2: Set identity manually');
+        await log('     git config --global user.name "Your Name"');
+        await log('     git config --global user.email "you@example.com"');
+        await log('');
+        await log('   Related error: "fatal: empty ident name (for <>) not allowed"');
+        await log('');
+        return false;
+      }
+    } else {
+      await log('');
+      await log('❌ Git identity not configured', { level: 'error' });
+      await log('');
+      await log('   Git commits require both user.name and user.email to be set.');
+      await log(`   ${gitIdentity.error || 'Configuration is incomplete'}`);
+      await log('');
+      await log('   Current configuration:');
+      await log(`     user.name:  ${gitIdentity.name || '(not set)'}`);
+      await log(`     user.email: ${gitIdentity.email || '(not set)'}`);
+      await log('');
+      await log('   🔧 How to fix:');
+      await log('');
+      await log('   Option 1: Use GitHub CLI to set identity from your account');
+      await log('     gh-setup-git-identity');
+      await log('');
+      await log('   Option 2: Set identity manually');
+      await log('     git config --global user.name "Your Name"');
+      await log('     git config --global user.email "you@example.com"');
+      await log('');
+      await log('   Option 3: Enable auto-repair (requires gh-setup-git-identity)');
+      await log('     solve <issue-url> --auto-gh-configuration-repair');
+      await log('');
+      await log('   Related error: "fatal: empty ident name (for <>) not allowed"');
+      await log('');
+      return false;
+    }
+  }
+
   // Skip tool connection validation if in dry-run mode or explicitly requested
   if (!skipToolConnection) {
     let isToolConnected = false;

package/src/solve.watch.lib.mjs

@@ -21,7 +21,7 @@ const fs = (await use('fs')).promises;
 
 // Import shared library functions
 const lib = await import('./lib.mjs');
-const { log, cleanErrorMessage, formatAligned } = lib;
+const { log, cleanErrorMessage, formatAligned, getLogFile } = lib;
 
 // Import feedback detection functions
 const feedbackLib = await import('./solve.feedback.lib.mjs');
@@ -29,6 +29,10 @@ const feedbackLib = await import('./solve.feedback.lib.mjs');
 const sentryLib = await import('./sentry.lib.mjs');
 const { reportError } = sentryLib;
 
+// Import GitHub functions for log attachment
+const githubLib = await import('./github.lib.mjs');
+const { sanitizeLogContent, attachLogToGitHub } = githubLib;
+
 const { detectAndCountFeedback } = feedbackLib;
 
 /**
@@ -517,6 +521,55 @@ export const watchForFeedback = async params => {
             }
           }
 
+          // Issue #1107: Attach log after each auto-restart session with its own cost estimation
+          // This ensures each restart has its own log comment instead of one combined log at the end
+          const shouldAttachLogs = argv.attachLogs || argv['attach-logs'];
+          if (isTemporaryWatch && prNumber && shouldAttachLogs) {
+            await log('');
+            await log(formatAligned('📎', 'Uploading auto-restart session log...', ''));
+            try {
+              const logFile = getLogFile();
+              if (logFile) {
+                // Use "Auto-restart X/Y Log" format as requested in issue #1107
+                const customTitle = `🔄 Auto-restart ${autoRestartCount}/${maxAutoRestartIterations} Log`;
+                const logUploadSuccess = await attachLogToGitHub({
+                  logFile,
+                  targetType: 'pr',
+                  targetNumber: prNumber,
+                  owner,
+                  repo,
+                  $,
+                  log,
+                  sanitizeLogContent,
+                  verbose: argv.verbose,
+                  customTitle,
+                  sessionId: latestSessionId,
+                  tempDir,
+                  anthropicTotalCostUSD: latestAnthropicCost,
+                  // Pass agent tool pricing data when available
+                  publicPricingEstimate: toolResult.publicPricingEstimate,
+                  pricingInfo: toolResult.pricingInfo,
+                });
+
+                if (logUploadSuccess) {
+                  await log(formatAligned('', '✅ Auto-restart session log uploaded to PR', '', 2));
+                } else {
+                  await log(formatAligned('', '⚠️  Could not upload auto-restart session log', '', 2));
+                }
+              }
+            } catch (logUploadError) {
+              reportError(logUploadError, {
+                context: 'attach_auto_restart_log',
+                prNumber,
+                owner,
+                repo,
+                autoRestartCount,
+                operation: 'upload_session_log',
+              });
+              await log(formatAligned('', `⚠️  Log upload error: ${cleanErrorMessage(logUploadError)}`, '', 2));
+            }
+          }
+
           await log('');
           if (isTemporaryWatch) {
             await log(formatAligned('✅', `${argv.tool.toUpperCase()} execution completed:`, 'Checking for remaining changes...'));

package/src/telegram-accept-invitations.lib.mjs

@@ -0,0 +1,128 @@
+/**
+ * Telegram /accept_invites command implementation
+ *
+ * This module provides the /accept_invites command functionality for the Telegram bot,
+ * allowing users to accept all pending GitHub repository and organization invitations.
+ *
+ * Features:
+ * - Accepts all pending repository invitations
+ * - Accepts all pending organization invitations
+ * - Provides detailed feedback on accepted invitations
+ * - Error handling with detailed error messages
+ *
+ * @see https://docs.github.com/en/rest/collaborators/invitations
+ * @see https://docs.github.com/en/rest/orgs/members
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+/**
+ * Escapes special characters in text for Telegram Markdown formatting
+ * @param {string} text - The text to escape
+ * @returns {string} The escaped text
+ */
+function escapeMarkdown(text) {
+  return String(text).replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
+}
+
+/**
+ * Registers the /accept_invites command handler with the bot
+ * @param {Object} bot - The Telegraf bot instance
+ * @param {Object} options - Options object
+ * @param {boolean} options.VERBOSE - Whether to enable verbose logging
+ * @param {Function} options.isOldMessage - Function to check if message is old
+ * @param {Function} options.isForwardedOrReply - Function to check if message is forwarded/reply
+ * @param {Function} options.isGroupChat - Function to check if chat is a group
+ * @param {Function} options.isChatAuthorized - Function to check if chat is authorized
+ * @param {Function} options.addBreadcrumb - Function to add breadcrumbs for monitoring
+ */
+export function registerAcceptInvitesCommand(bot, options) {
+  const { VERBOSE = false, isOldMessage, isForwardedOrReply, isGroupChat, isChatAuthorized, addBreadcrumb } = options;
+
+  bot.command(/^accept[_-]?invites$/i, async ctx => {
+    VERBOSE && console.log('[VERBOSE] /accept-invites command received');
+    await addBreadcrumb({
+      category: 'telegram.command',
+      message: '/accept-invites command received',
+      level: 'info',
+      data: { chatId: ctx.chat?.id, chatType: ctx.chat?.type, userId: ctx.from?.id, username: ctx.from?.username },
+    });
+    if (isOldMessage(ctx) || isForwardedOrReply(ctx)) return;
+    if (!isGroupChat(ctx))
+      return await ctx.reply('❌ The /accept_invites command only works in group chats. Please add this bot to a group and make it an admin.', {
+        reply_to_message_id: ctx.message.message_id,
+      });
+    const chatId = ctx.chat.id;
+    if (!isChatAuthorized(chatId))
+      return await ctx.reply(`❌ This chat (ID: ${chatId}) is not authorized to use this bot. Please contact the bot administrator.`, {
+        reply_to_message_id: ctx.message.message_id,
+      });
+
+    const fetchingMessage = await ctx.reply('🔄 Fetching pending GitHub invitations...', { reply_to_message_id: ctx.message.message_id });
+    const accepted = [];
+    const errors = [];
+
+    try {
+      // Fetch repository invitations
+      const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
+      const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
+      VERBOSE && console.log(`[VERBOSE] Found ${repoInvitations.length} pending repo invitations`);
+
+      // Accept each repo invitation
+      for (const inv of repoInvitations) {
+        const repoName = inv.repository?.full_name || 'unknown';
+        try {
+          await exec(`gh api -X PATCH /user/repository_invitations/${inv.id}`);
+          accepted.push(`📦 Repository: ${repoName}`);
+          VERBOSE && console.log(`[VERBOSE] Accepted repo invitation: ${repoName}`);
+        } catch (e) {
+          errors.push(`📦 ${repoName}: ${e.message}`);
+          VERBOSE && console.log(`[VERBOSE] Failed to accept repo invitation ${repoName}: ${e.message}`);
+        }
+      }
+
+      // Fetch organization invitations
+      const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+      const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
+      const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
+      VERBOSE && console.log(`[VERBOSE] Found ${pendingOrgs.length} pending org invitations`);
+
+      // Accept each org invitation
+      for (const membership of pendingOrgs) {
+        const orgName = membership.organization?.login || 'unknown';
+        try {
+          await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
+          accepted.push(`🏢 Organization: ${orgName}`);
+          VERBOSE && console.log(`[VERBOSE] Accepted org invitation: ${orgName}`);
+        } catch (e) {
+          errors.push(`🏢 ${orgName}: ${e.message}`);
+          VERBOSE && console.log(`[VERBOSE] Failed to accept org invitation ${orgName}: ${e.message}`);
+        }
+      }
+
+      // Build response message
+      let message = '✅ *GitHub Invitations Processed*\n\n';
+      if (accepted.length === 0 && errors.length === 0) {
+        message += 'No pending invitations found.';
+      } else {
+        if (accepted.length > 0) {
+          message += '*Accepted:*\n' + accepted.map(a => `  • ${escapeMarkdown(a)}`).join('\n') + '\n\n';
+        }
+        if (errors.length > 0) {
+          message += '*Errors:*\n' + errors.map(e => `  • ${escapeMarkdown(e)}`).join('\n');
+        }
+        if (accepted.length > 0 && errors.length === 0) {
+          message += `\n🎉 Successfully accepted ${accepted.length} invitation(s)!`;
+        }
+      }
+
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, message, { parse_mode: 'Markdown' });
+    } catch (error) {
+      console.error('Error in /accept-invites:', error);
+      await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ Error fetching invitations: ${escapeMarkdown(error.message)}\n\nMake sure \`gh\` CLI is installed and authenticated.`, { parse_mode: 'Markdown' });
+    }
+  });
+}

package/src/telegram-bot.mjs

@@ -761,8 +761,9 @@ bot.command('help', async ctx => {
 
   message += '*/limits* - Show usage limits\n';
   message += '*/version* - Show bot and runtime versions\n';
+  message += '*/accept\\_invites* - Accept all pending GitHub invitations\n';
   message += '*/help* - Show this help message\n\n';
-  message += '⚠️ *Note:* /solve, /hive, /limits and /version commands only work in group chats.\n\n';
+  message += '⚠️ *Note:* /solve, /hive, /limits, /version and /accept\\_invites 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 += '• `--base-branch <branch>` or `-b` - Target branch for PR (default: repo default branch)\n';
@@ -883,6 +884,19 @@ bot.command('version', async ctx => {
   if (!result.success) return await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, `❌ ${escapeMarkdownV2(result.error, { preserveCodeBlocks: true })}`, { parse_mode: 'MarkdownV2' });
   await ctx.telegram.editMessageText(fetchingMessage.chat.id, fetchingMessage.message_id, undefined, '🤖 *Version Information*\n\n' + formatVersionMessage(result.versions), { parse_mode: 'Markdown' });
 });
+
+// Register /accept_invites command from separate module
+// This keeps telegram-bot.mjs under the 1500 line limit
+const { registerAcceptInvitesCommand } = await import('./telegram-accept-invitations.lib.mjs');
+registerAcceptInvitesCommand(bot, {
+  VERBOSE,
+  isOldMessage,
+  isForwardedOrReply,
+  isGroupChat,
+  isChatAuthorized,
+  addBreadcrumb,
+});
+
 bot.command(/^solve$/i, async ctx => {
   if (VERBOSE) {
     console.log('[VERBOSE] /solve command received');