fix: auto-initialize empty GitOps repo instead of erroring

go-git cannot clone a remote with no commits, so the first GitOps publish
to a freshly-created repo failed with "clone: remote repository is empty".
Detect transport.ErrEmptyRemoteRepository and fall back to an in-memory
init on the target branch wired to the remote; the first WriteFile commit
then creates the branch on push (explicit branch refspec).

Author: thbertoldi

aif-operator/internal/git/client.go

@@ -11,8 +11,10 @@ import (
 	"github.com/go-git/go-billy/v5"
 	"github.com/go-git/go-billy/v5/memfs"
 	gogit "github.com/go-git/go-git/v5"
+	"github.com/go-git/go-git/v5/config"
 	"github.com/go-git/go-git/v5/plumbing"
 	"github.com/go-git/go-git/v5/plumbing/object"
+	"github.com/go-git/go-git/v5/plumbing/transport"
 	gogithttp "github.com/go-git/go-git/v5/plumbing/transport/http"
 	"github.com/go-git/go-git/v5/storage/memory"
 
@@ -124,6 +126,12 @@ func (c *Client) clone(ctx context.Context) (*gogit.Repository, *gogit.Worktree,
 		Depth:         1,
 		Auth:          c.auth,
 	})
+	if errors.Is(err, transport.ErrEmptyRemoteRepository) {
+		// A freshly created GitOps repo has no commits yet, so go-git cannot
+		// clone it. Initialize an in-memory repo on the target branch wired to
+		// the remote; the first WriteFile commit then creates the branch on push.
+		return c.initEmpty()
+	}
 	if err != nil {
 		return nil, nil, fmt.Errorf("clone: %w", err)
 	}
@@ -134,6 +142,32 @@ func (c *Client) clone(ctx context.Context) (*gogit.Repository, *gogit.Worktree,
 	return repo, wt, nil
 }
 
+// initEmpty builds an in-memory repository positioned on c.branch with the
+// remote configured, for when the remote exists but has no commits.
+func (c *Client) initEmpty() (*gogit.Repository, *gogit.Worktree, error) {
+	repo, err := gogit.Init(memory.NewStorage(), memfs.New())
+	if err != nil {
+		return nil, nil, fmt.Errorf("init empty repo: %w", err)
+	}
+	if _, err := repo.CreateRemote(&config.RemoteConfig{
+		Name: gogit.DefaultRemoteName,
+		URLs: []string{c.repoURL},
+	}); err != nil {
+		return nil, nil, fmt.Errorf("create remote: %w", err)
+	}
+	// Point HEAD at the target branch so the initial commit lands there even
+	// though it does not exist yet (orphan/initial commit).
+	headRef := plumbing.NewSymbolicReference(plumbing.HEAD, plumbing.NewBranchReferenceName(c.branch))
+	if err := repo.Storer.SetReference(headRef); err != nil {
+		return nil, nil, fmt.Errorf("set HEAD to %s: %w", c.branch, err)
+	}
+	wt, err := repo.Worktree()
+	if err != nil {
+		return nil, nil, fmt.Errorf("worktree: %w", err)
+	}
+	return repo, wt, nil
+}
+
 func (c *Client) commitAndPush(ctx context.Context, repo *gogit.Repository, wt *gogit.Worktree, msg string) (string, error) {
 	hash, err := wt.Commit(msg, &gogit.CommitOptions{
 		Author: &object.Signature{
@@ -145,8 +179,12 @@ func (c *Client) commitAndPush(ctx context.Context, repo *gogit.Repository, wt *
 	if err != nil {
 		return "", fmt.Errorf("commit: %w", err)
 	}
+	// Push the branch explicitly so this also creates the branch on a
+	// previously-empty remote (where there is no tracking config to default to).
+	branchRef := plumbing.NewBranchReferenceName(c.branch)
 	if err := repo.PushContext(ctx, &gogit.PushOptions{
 		RemoteName: gogit.DefaultRemoteName,
+		RefSpecs:   []config.RefSpec{config.RefSpec(fmt.Sprintf("%s:%s", branchRef, branchRef))},
 		Auth:       c.auth,
 	}); err != nil && !errors.Is(err, gogit.NoErrAlreadyUpToDate) {
 		return "", fmt.Errorf("push: %w", err)

aif-operator/internal/git/client_test.go

@@ -69,6 +69,16 @@ func newTestRemote(t *testing.T) string {
 	return "file://" + remoteDir
 }
 
+// newEmptyTestRemote creates a bare git repo with NO commits (no branches),
+// mimicking a freshly created, never-initialized GitOps repository.
+func newEmptyTestRemote(t *testing.T) string {
+	t.Helper()
+	remoteDir := t.TempDir()
+	_, err := gogit.PlainInit(remoteDir, true)
+	require.NoError(t, err)
+	return "file://" + remoteDir
+}
+
 // readFileFromRemote clones the remote and reads filePath. Returns error if file not found.
 func readFileFromRemote(t *testing.T, remoteURL, filePath string) (string, error) {
 	t.Helper()
@@ -120,6 +130,31 @@ func TestWriteFile(t *testing.T) {
 	require.Equal(t, "content: true\n", got)
 }
 
+func TestWriteFile_EmptyRemoteInitializes(t *testing.T) {
+	remote := newEmptyTestRemote(t)
+	c := newClient(t, remote)
+
+	hash, err := c.WriteFile(context.Background(),
+		filepath.Join("workloads", "test.yaml"),
+		"content: true\n",
+		"chore: initialize gitops repo")
+	require.NoError(t, err)
+	require.NotEmpty(t, hash)
+
+	got, err := readFileFromRemote(t, remote, filepath.Join("workloads", "test.yaml"))
+	require.NoError(t, err)
+	require.Equal(t, "content: true\n", got)
+}
+
+func TestDeleteFile_EmptyRemoteIsNoOp(t *testing.T) {
+	remote := newEmptyTestRemote(t)
+	c := newClient(t, remote)
+
+	hash, err := c.DeleteFile(context.Background(), "workloads/missing.yaml", "remove")
+	require.NoError(t, err)
+	require.Empty(t, hash) // nothing to delete on an empty repo
+}
+
 func TestWriteFile_UnchangedContentIsNoOp(t *testing.T) {
 	remote := newTestRemote(t)
 	c := newClient(t, remote)