@link-assistant/hive-mind 1.2.11 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @link-assistant/hive-mind
 
+## 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
+
+- a403c0e: Add --auto-gitkeep-file option to automatically fallback to .gitkeep when CLAUDE.md is in .gitignore
+
+  This feature pre-checks if CLAUDE.md would be ignored by .gitignore BEFORE creating the file, preventing the "paths are ignored by one of your .gitignore files" error. When detected, automatically switches to .gitkeep mode. Enabled by default (--auto-gitkeep-file=true).
+
 ## 1.2.11
 
 ### Patch Changes
@@ -952,7 +979,7 @@
 
   This feature allows users to choose which file type to use for PR creation:
   - `--claude-file` (default: true): Use CLAUDE.md file for task details
-  - `--gitkeep-file` (default: false, experimental): Use .gitkeep file instead
+  - `--gitkeep-file` (default: false): Use .gitkeep file instead
 
   The flags are mutually exclusive:
   - Using `--gitkeep-file` automatically disables `--claude-file`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.2.11",
+  "version": "1.4.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.auto-pr.lib.mjs

@@ -31,12 +31,20 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
 
   try {
     // Determine which file to create based on CLI flags
-    const useClaudeFile = argv.claudeFile !== false; // Default to true
-    const useGitkeepFile = argv.gitkeepFile === true; // Default to false
+    let useClaudeFile = argv.claudeFile !== false;
+    const useAutoGitkeepFile = argv.autoGitkeepFile !== false;
+
+    // Pre-check: If CLAUDE.md would be ignored by .gitignore, automatically switch to .gitkeep mode
+    if (useClaudeFile && useAutoGitkeepFile) {
+      const checkResult = await $({ cwd: tempDir, silent: true })`git check-ignore CLAUDE.md 2>/dev/null`;
+      if (checkResult.code === 0) {
+        await log(formatAligned('ℹ️', 'Pre-check:', 'CLAUDE.md is in .gitignore, switching to .gitkeep mode\n'));
+        useClaudeFile = false;
+      }
+    }
 
-    // Log which mode we're using
     if (argv.verbose) {
-      await log(`   Using ${useClaudeFile ? 'CLAUDE.md' : '.gitkeep'} mode (--claude-file=${useClaudeFile}, --gitkeep-file=${useGitkeepFile})`, { verbose: true });
+      await log(`   Using ${useClaudeFile ? 'CLAUDE.md' : '.gitkeep'} mode (--claude-file=${argv.claudeFile !== false}, --gitkeep-file=${argv.gitkeepFile === true}, --auto-gitkeep-file=${useAutoGitkeepFile})`, { verbose: true });
     }
 
     let filePath;
@@ -62,14 +70,13 @@ export async function handleAutoPrCreation({ argv, tempDir, branchName, issueNum
         }
       }
     } else {
-      // Create .gitkeep file directly (experimental mode)
-      await log(formatAligned('📝', 'Creating:', '.gitkeep (experimental mode)'));
+      // .gitkeep mode (via explicit --gitkeep-file or auto-gitkeep-file fallback)
+      const modeDesc = argv.gitkeepFile === true ? '.gitkeep (explicit --gitkeep-file)' : '.gitkeep (CLAUDE.md is ignored)';
+      await log(formatAligned('📝', 'Creating:', modeDesc));
 
       filePath = path.join(tempDir, '.gitkeep');
       fileName = '.gitkeep';
-
-      // .gitkeep files are typically small, no need to check for existing content
-      // But we'll check if it exists for proper handling
+      // Check if .gitkeep already exists for proper handling
       try {
         existingContent = await fs.readFile(filePath, 'utf8');
         fileExisted = true;
@@ -125,12 +132,13 @@ Proceed.
         finalContent = taskInfo;
       }
     } else {
-      // .gitkeep: Use minimal metadata format
+      // .gitkeep: Use minimal metadata format (explicit --gitkeep-file or auto-gitkeep-file fallback)
+      const creationReason = argv.gitkeepFile === true ? '# This file was created with --gitkeep-file flag' : '# This file was created because CLAUDE.md is in .gitignore (--auto-gitkeep-file=true)';
       const gitkeepContent = `# Auto-generated file for PR creation
 # Issue: ${issueUrl}
 # Branch: ${branchName}
 # Timestamp: ${timestamp}
-# This file was created with --gitkeep-file flag (experimental)
+${creationReason}
 # It will be removed when the task is complete`;
 
       if (fileExisted && existingContent) {
@@ -289,9 +297,8 @@ Proceed.
     }
 
     await log(formatAligned('📝', 'Creating commit:', `With ${commitFileName} file`));
-
-    // Determine commit message based on which file is being committed
-    const fileDesc = commitFileName === 'CLAUDE.md' ? 'CLAUDE.md with task information for AI processing' : `.gitkeep for PR creation (${useGitkeepFile ? 'created with --gitkeep-file flag (experimental)' : 'CLAUDE.md is in .gitignore'})`;
+    // Commit message distinguishes between explicit --gitkeep-file and auto-gitkeep-file fallback
+    const fileDesc = commitFileName === 'CLAUDE.md' ? 'CLAUDE.md with task information for AI processing' : `.gitkeep for PR creation (${argv.gitkeepFile === true ? 'created with --gitkeep-file flag' : 'CLAUDE.md is in .gitignore'})`;
     const commitMessage = `Initial commit with task details\n\nAdding ${fileDesc}.\nThis file will be removed when the task is complete.\n\nIssue: ${issueUrl}`;
 
     // Use explicit cwd option for better reliability

package/src/solve.config.lib.mjs

@@ -130,9 +130,14 @@ export const createYargsConfig = yargsInstance => {
       })
       .option('gitkeep-file', {
         type: 'boolean',
-        description: 'Create .gitkeep file instead of CLAUDE.md (experimental, mutually exclusive with --claude-file)',
+        description: 'Create .gitkeep file instead of CLAUDE.md (mutually exclusive with --claude-file)',
         default: false,
       })
+      .option('auto-gitkeep-file', {
+        type: 'boolean',
+        description: 'Automatically use .gitkeep if CLAUDE.md is in .gitignore (pre-checks before creating file)',
+        default: true,
+      })
       .option('attach-logs', {
         type: 'boolean',
         description: 'Upload the solution draft log file to the Pull Request on completion (⚠️ WARNING: May expose sensitive data)',
@@ -316,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...'));