@link-assistant/hive-mind 1.32.3 → 1.33.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @link-assistant/hive-mind
 
+## 1.33.0
+
+### Minor Changes
+
+- f7a2fdd: Add --auto-init-repository option to automatically initialize empty repositories by creating a simple README.md file, enabling branch creation and pull request workflows on repositories with no commits
+
 ## 1.32.3
 
 ### Patch Changes

package/README.md

@@ -341,12 +341,13 @@ solve <issue-url> [options]
 
 **Other useful options:**
 
-| Option          | Alias | Description                                      | Default |
-| --------------- | ----- | ------------------------------------------------ | ------- |
-| `--tool`        |       | AI tool (claude, opencode, codex, agent)         | claude  |
-| `--verbose`     | `-v`  | Enable verbose logging                           | false   |
-| `--attach-logs` |       | Attach logs to PR (⚠️ may expose sensitive data) | false   |
-| `--help`        | `-h`  | Show all available options                       | -       |
+| Option                   | Alias | Description                                      | Default |
+| ------------------------ | ----- | ------------------------------------------------ | ------- |
+| `--tool`                 |       | AI tool (claude, opencode, codex, agent)         | claude  |
+| `--verbose`              | `-v`  | Enable verbose logging                           | false   |
+| `--attach-logs`          |       | Attach logs to PR (⚠️ may expose sensitive data) | false   |
+| `--auto-init-repository` |       | Auto-initialize empty repos (creates README.md)  | false   |
+| `--help`                 | `-h`  | Show all available options                       | -       |
 
 > **📖 Full options list**: See [docs/CONFIGURATION.md](./docs/CONFIGURATION.md#solve-options) for all available options including forking, auto-continue, watch mode, and experimental features.
 

package/package.json

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

package/src/option-suggestions.lib.mjs

@@ -215,6 +215,7 @@ const KNOWN_OPTION_NAMES = [
   'prompt-examples-folder',
   'session-type',
   'working-directory',
+  'auto-init-repository',
   'prompt-ensure-all-requirements-are-met',
   'finalize',
   'finalize-model',

package/src/solve.branch-errors.lib.mjs

@@ -232,15 +232,35 @@ export async function handleBranchCreationError({ branchName, errorOutput, tempD
     await log(`     ${line}`);
   }
   await log('');
-  await log('  💡 Possible causes:');
-  await log('     • Branch name already exists');
-  await log('     • Uncommitted changes in repository');
-  await log('     • Git configuration issues');
-  await log('');
-  await log('  🔧 How to fix:');
-  await log('     1. Try running the command again (uses random names)');
-  await log(`     2. Check git status: cd ${tempDir} && git status`);
-  await log(`     3. View existing branches: cd ${tempDir} && git branch -a`);
+
+  // Check if this is an empty repository error (no commits to branch from)
+  const isEmptyRepoError = errorOutput.includes('is not a commit') || errorOutput.includes('not a valid object name') || errorOutput.includes('unknown revision');
+  if (isEmptyRepoError) {
+    await log('  💡 Root cause:');
+    await log('     The repository appears to be empty (no commits).');
+    await log('     Cannot create a branch from a non-existent commit.');
+    await log('');
+    await log('  🔧 How to fix:');
+    await log('     Use the --auto-init-repository flag to automatically initialize the repository:');
+    if (owner && repo) {
+      await log(`       solve https://github.com/${owner}/${repo}/issues/<number> --auto-init-repository`);
+    } else {
+      await log('       solve <issue-url> --auto-init-repository');
+    }
+    await log('');
+    await log('     This will create a simple README.md file to make the repository non-empty,');
+    await log('     allowing branch creation and pull request workflows to proceed.');
+  } else {
+    await log('  💡 Possible causes:');
+    await log('     • Branch name already exists');
+    await log('     • Uncommitted changes in repository');
+    await log('     • Git configuration issues');
+    await log('');
+    await log('  🔧 How to fix:');
+    await log('     1. Try running the command again (uses random names)');
+    await log(`     2. Check git status: cd ${tempDir} && git status`);
+    await log(`     3. View existing branches: cd ${tempDir} && git branch -a`);
+  }
 }
 
 export async function handleBranchVerificationError({ isContinueMode, branchName, actualBranch, prNumber, owner, repo, tempDir, formatAligned, log, $ }) {

package/src/solve.config.lib.mjs

@@ -362,6 +362,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Guide Claude to use agent-commander CLI (start-agent) instead of native Task tool for subagent delegation. Allows using any supported agent type (claude, opencode, codex, agent) with unified API. Only works with --tool claude and requires agent-commander to be installed.',
     default: false,
   },
+  'auto-init-repository': {
+    type: 'boolean',
+    description: 'Automatically initialize empty repositories by creating a simple README.md file. Only works when you have write access to the repository. This allows branch creation and pull request workflows to proceed on repositories that have no commits.',
+    default: false,
+  },
   'attach-solution-summary': {
     type: 'boolean',
     description: 'Attach the AI solution summary (from the result field) as a comment to the PR/issue after completion. The summary is extracted from the AI tool JSON output and posted under a "Solution summary" header.',

package/src/solve.mjs

@@ -534,11 +534,16 @@ try {
   });
 
   // Verify default branch and status using the new module
+  // Pass argv, owner, repo, issueUrl for empty repository auto-initialization (--auto-init-repository)
   const defaultBranch = await verifyDefaultBranchAndStatus({
     tempDir,
     log,
     formatAligned,
     $,
+    argv,
+    owner,
+    repo,
+    issueUrl,
   });
   // Create or checkout branch using the new module
   const branchName = await createOrCheckoutBranch({

package/src/solve.repo-setup.lib.mjs

@@ -56,7 +56,7 @@ async function setupPrForkRemote(tempDir, argv, prForkOwner, repo, isContinueMod
   return await setupPrForkFn(tempDir, argv, prForkOwner, repo, isContinueMode, owner);
 }
 
-export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned, $ }) {
+export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned, $, argv, owner, repo, issueUrl }) {
   // Verify we're on the default branch and get its name
   const defaultBranchResult = await $({ cwd: tempDir })`git branch --show-current`;
 
@@ -66,27 +66,128 @@ export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned
     throw new Error('Failed to get current branch');
   }
 
-  const defaultBranch = defaultBranchResult.stdout.toString().trim();
+  let defaultBranch = defaultBranchResult.stdout.toString().trim();
   if (!defaultBranch) {
-    await log('');
-    await log(`${formatAligned('❌', 'DEFAULT BRANCH DETECTION FAILED', '')}`, { level: 'error' });
-    await log('');
-    await log('  🔍 What happened:');
-    await log("     Unable to determine the repository's default branch.");
-    await log('');
-    await log('  💡 This might mean:');
-    await log('     • Repository is empty (no commits)');
-    await log('     • Unusual repository configuration');
-    await log('     • Git command issues');
-    await log('');
-    await log('  🔧 How to fix:');
-    await log('     1. Check repository status');
-    await log(`     2. Verify locally: cd ${tempDir} && git branch`);
-    await log(`     3. Check remote: cd ${tempDir} && git branch -r`);
-    await log('');
-    throw new Error('Default branch detection failed');
+    // Repository is likely empty (no commits) - detect and handle
+    const isEmptyRepo = await detectEmptyRepository(tempDir, $);
+
+    if (isEmptyRepo && argv && argv.autoInitRepository && owner && repo) {
+      // --auto-init-repository is enabled, try to initialize
+      await log('');
+      await log(`${formatAligned('⚠️', 'EMPTY REPOSITORY', 'detected')}`, { level: 'warn' });
+      await log(`${formatAligned('', '', `Repository ${owner}/${repo} contains no commits`)}`);
+      await log(`${formatAligned('', '', '--auto-init-repository is enabled, attempting initialization...')}`);
+      await log('');
+
+      const repository = await import('./solve.repository.lib.mjs');
+      const { tryInitializeEmptyRepository } = repository;
+      const initialized = await tryInitializeEmptyRepository(owner, repo);
+
+      if (initialized) {
+        await log('');
+        await log(`${formatAligned('🔄', 'Re-fetching:', 'Pulling initialized repository...')}`);
+        // Wait for GitHub to process the new file
+        await new Promise(resolve => setTimeout(resolve, 2000));
+
+        // Re-fetch the origin to get the new commit
+        const fetchResult = await $({ cwd: tempDir })`git fetch origin`;
+        if (fetchResult.code !== 0) {
+          await log(`${formatAligned('❌', 'Fetch failed:', 'Could not fetch after initialization')}`, { level: 'error' });
+          throw new Error('Failed to fetch after empty repository initialization');
+        }
+
+        // Determine default branch name from the remote
+        const remoteHeadResult = await $({ cwd: tempDir })`git remote show origin`;
+        let remoteBranch = 'main'; // default fallback
+        if (remoteHeadResult.code === 0) {
+          const remoteOutput = remoteHeadResult.stdout.toString();
+          const headMatch = remoteOutput.match(/HEAD branch:\s*(\S+)/);
+          if (headMatch) {
+            remoteBranch = headMatch[1];
+          }
+        }
+
+        // Checkout the remote branch locally
+        const checkoutResult = await $({ cwd: tempDir })`git checkout -b ${remoteBranch} origin/${remoteBranch}`;
+        if (checkoutResult.code !== 0) {
+          // Try alternative: maybe the branch already exists locally somehow
+          const altResult = await $({ cwd: tempDir })`git checkout ${remoteBranch}`;
+          if (altResult.code !== 0) {
+            await log(`${formatAligned('❌', 'Checkout failed:', `Could not checkout ${remoteBranch} after initialization`)}`, { level: 'error' });
+            throw new Error('Failed to checkout branch after empty repository initialization');
+          }
+        }
+
+        defaultBranch = remoteBranch;
+        await log(`${formatAligned('✅', 'Repository initialized:', `Now on branch ${defaultBranch}`)}`);
+        await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
+      } else {
+        // Auto-init failed - provide helpful message with --auto-init-repository context
+        await log('');
+        await log(`${formatAligned('❌', 'AUTO-INIT FAILED', '')}`, { level: 'error' });
+        await log('');
+        await log('  🔍 What happened:');
+        await log(`     Repository ${owner}/${repo} is empty (no commits).`);
+        await log('     --auto-init-repository was enabled but initialization failed.');
+        await log('     You may not have write access to create files in the repository.');
+        await log('');
+        await log('  💡 How to fix:');
+        await log('     Option 1: Ask repository owner to add initial content');
+        await log('              Even a simple README.md file would allow branch creation');
+        await log('');
+        await log(`     Option 2: Manually initialize: gh api repos/${owner}/${repo}/contents/README.md \\`);
+        await log('                --method PUT --field message="Initialize repository" \\');
+        await log('                --field content="$(echo "# repo" | base64)"');
+        await log('');
+
+        // Post a comment on the issue informing about the empty repository
+        await tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ });
+
+        throw new Error('Empty repository auto-initialization failed');
+      }
+    } else if (isEmptyRepo) {
+      // Empty repo detected but --auto-init-repository is not enabled
+      await log('');
+      await log(`${formatAligned('❌', 'EMPTY REPOSITORY DETECTED', '')}`, { level: 'error' });
+      await log('');
+      await log('  🔍 What happened:');
+      await log(`     The repository${owner && repo ? ` ${owner}/${repo}` : ''} is empty (no commits).`);
+      await log('     Cannot create branches or pull requests on an empty repository.');
+      await log('');
+      await log('  💡 How to fix:');
+      await log('     Option 1: Use --auto-init-repository flag to automatically create a README.md');
+      await log(`              solve <issue-url> --auto-init-repository`);
+      await log('');
+      await log('     Option 2: Ask repository owner to add initial content');
+      await log('              Even a simple README.md file would allow branch creation');
+      await log('');
+
+      // Post a comment on the issue informing about the empty repository
+      await tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ });
+
+      throw new Error('Empty repository detected - use --auto-init-repository to initialize');
+    } else {
+      // Not an empty repo, some other issue with branch detection
+      await log('');
+      await log(`${formatAligned('❌', 'DEFAULT BRANCH DETECTION FAILED', '')}`, { level: 'error' });
+      await log('');
+      await log('  🔍 What happened:');
+      await log("     Unable to determine the repository's default branch.");
+      await log('');
+      await log('  💡 This might mean:');
+      await log('     • Unusual repository configuration');
+      await log('     • Git command issues');
+      await log('');
+      await log('  🔧 How to fix:');
+      await log('     1. Check repository status');
+      await log(`     2. Verify locally: cd ${tempDir} && git branch`);
+      await log(`     3. Check remote: cd ${tempDir} && git branch -r`);
+      await log('');
+      throw new Error('Default branch detection failed');
+    }
+  } else {
+    await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
   }
-  await log(`\n${formatAligned('📌', 'Default branch:', defaultBranch)}`);
 
   // Ensure we're on a clean default branch
   const statusResult = await $({ cwd: tempDir })`git status --porcelain`;
@@ -106,3 +207,79 @@ export async function verifyDefaultBranchAndStatus({ tempDir, log, formatAligned
 
   return defaultBranch;
 }
+
+/**
+ * Try to post a comment on the issue informing the user about the empty repository.
+ * This is a non-critical operation - errors are silently ignored.
+ * When --auto-init-repository succeeds, no comment is posted (no action needed from the user).
+ */
+async function tryCommentOnIssueAboutEmptyRepo({ issueUrl, owner, repo, log, formatAligned, $ }) {
+  if (!issueUrl) return;
+
+  try {
+    const issueMatch = issueUrl.match(/\/issues\/(\d+)/);
+    if (!issueMatch) return;
+
+    const issueNumber = issueMatch[1];
+    await log(`${formatAligned('💬', 'Creating comment:', 'Informing about empty repository...')}`);
+
+    const commentBody = `## ⚠️ Repository Initialization Required
+
+Hello! I attempted to work on this issue, but encountered a problem:
+
+**Issue**: The repository is empty (no commits) and branches cannot be created.
+**Reason**: Git cannot create branches in a repository with no commits.
+
+### 🔧 How to resolve:
+
+**Option 1: Use \`--auto-init-repository\` flag**
+Re-run the solver with the \`--auto-init-repository\` flag to automatically create a simple README.md:
+\`\`\`
+solve ${issueUrl} --auto-init-repository
+\`\`\`
+
+**Option 2: Initialize the repository yourself**
+Please add initial content to the repository. Even a simple README.md (even if it is empty or contains just the title) file would make it possible to create branches and work on this issue.
+
+Once the repository contains at least one commit with any file, I'll be able to proceed with solving this issue.
+
+Thank you!`;
+
+    const commentResult = await $`gh issue comment ${issueNumber} --repo ${owner}/${repo} --body ${commentBody}`;
+    if (commentResult.code === 0) {
+      await log(`${formatAligned('✅', 'Comment created:', `Posted to issue #${issueNumber}`)}`);
+    } else {
+      await log(`${formatAligned('⚠️', 'Note:', 'Could not post comment to issue (this is not critical)')}`);
+    }
+  } catch {
+    // Silently ignore comment creation errors - not critical to the process
+    await log(`${formatAligned('⚠️', 'Note:', 'Could not post comment to issue (this is not critical)')}`);
+  }
+}
+
+/**
+ * Detect if a cloned repository is empty (has no commits).
+ * An empty repository has no branches and no commits.
+ */
+async function detectEmptyRepository(tempDir, $) {
+  // Check if there are any commits in the repository
+  const logResult = await $({ cwd: tempDir })`git rev-parse HEAD 2>&1`;
+  if (logResult.code !== 0) {
+    // git rev-parse HEAD fails when there are no commits
+    const output = (logResult.stdout || logResult.stderr || '').toString();
+    if (output.includes('unknown revision') || output.includes('bad default revision') || output.includes('does not have any commits')) {
+      return true;
+    }
+  }
+
+  // Also check if there are any remote branches
+  const remoteBranchResult = await $({ cwd: tempDir })`git branch -r`;
+  if (remoteBranchResult.code === 0) {
+    const branches = remoteBranchResult.stdout.toString().trim();
+    if (!branches) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/src/solve.repository.lib.mjs

@@ -317,8 +317,9 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
 };
 
 // Try to initialize an empty repository by creating a simple README.md
-// This makes the repository forkable
-const tryInitializeEmptyRepository = async (owner, repo) => {
+// This makes the repository forkable and allows branch creation
+// Exported for use in solve.repo-setup.lib.mjs (direct access path for empty repos)
+export const tryInitializeEmptyRepository = async (owner, repo) => {
   try {
     await log(`${formatAligned('🔧', 'Auto-fix:', 'Attempting to initialize empty repository...')}`);