go-cli-init-git-empty-repo

Answer

Root cause. initGit() in the hivemind init command wrote .gitignore and then hard-returned errors.New("git init not implemented"), so the CLI printed Git: skipped (git init not implemented). Replacing it with a bare git init is not enough: pkg/git WorktreeManager.CreateWorktree calls repo.Head() (go-git), which errors with reference not found on a zero-commit repository — so Ralph loops that create per-agent worktrees still died.

The fix — replace initGit() with a real implementation: exec git init, stage everything, and create the initial commit using inline -c user.name/user.email identity so no global/user config is read or written. Guard the whole thing with exec.LookPath so a missing git binary degrades to the existing "skipped" message instead of a panic.

package cli

import (
    "fmt"
    "os"
    "os/exec"
    "path/filepath"
)

// initGit initializes the repo and creates the mandatory initial commit.
// A bare `git init` leaves a zero-commit repo: pkg/git WorktreeManager
// CreateWorktree calls repo.Head(), which fails with "reference not found"
// on a repo with no commits. The initial commit is required.
// Identity is passed inline via -c so global/user config is never touched.
func initGit() error {
    // .gitignore first, as before.
    if err := os.WriteFile(".gitignore", []byte("*.pyc\n.env\n"), 0o644); err != nil {
        return fmt.Errorf("write .gitignore: %w", err)
    }

    // Graceful degradation: skip when the git binary is missing.
    gitBin, err := exec.LookPath("git")
    if err != nil {
        return fmt.Errorf("git binary not found (skipping git init): %w", err)
    }

    identity := []string{"-c", "user.name=hivemind", "-c", "user.email=hivemind@localhost"}

    if out, err := runGit(gitBin, append(identity, "init", "-q")...); err != nil {
        return fmt.Errorf("git init: %w (%s)", err, out)
    }
    if out, err := runGit(gitBin, "add", "-A"); err != nil {
        return fmt.Errorf("git add: %w (%s)", err, out)
    }
    // --allow-empty so a repo initialized from an empty dir still gets a HEAD.
    if out, err := runGit(gitBin, append(identity, "commit", "-q", "-m", "Initial commit", "--allow-empty")...); err != nil {
        return fmt.Errorf("git commit: %w (%s)", err, out)
    }
    return nil
}

func runGit(bin string, args ...string) (string, error) {
    cmd := exec.Command(bin, args...)
    out, err := cmd.CombinedOutput()
    return string(out), err
}

Caller stays unchanged — it already tolerates an error return as "skipped":

if err := initGit(); err != nil {
    fmt.Println("Git: skipped (", err, ")")
} else {
    fmt.Println("Git: initialized")
}