Repair missing repo records from config

Co-authored-by: Andrew <andrewxhill@gmail.com>

Author: andrewxhill-ai

internal/app/publish.go

@@ -3,6 +3,7 @@ package app
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -126,10 +127,35 @@ func loadRepoContext(repoPath string) (git.RepositoryLayout, string, policy.File
 		return git.RepositoryLayout{}, "", policy.File{}, state.RepositoryRecord{}, state.Store{}, err
 	}
 
-	repoRecord, err := store.GetRepositoryByPath(context.Background(), repoRoot)
+	repoRecord, _, err := ensureRepositoryRecord(context.Background(), store, repoRoot, cfg)
 	if err != nil {
 		return git.RepositoryLayout{}, "", policy.File{}, state.RepositoryRecord{}, state.Store{}, err
 	}
 
 	return layout, repoRoot, cfg, repoRecord, store, nil
 }
+
+func ensureRepositoryRecord(ctx context.Context, store state.Store, repoRoot string, cfg policy.File) (state.RepositoryRecord, bool, error) {
+	record, err := store.GetRepositoryByPath(ctx, repoRoot)
+	if err == nil {
+		return record, false, nil
+	}
+	if !errors.Is(err, state.ErrNotFound) {
+		return state.RepositoryRecord{}, false, err
+	}
+	if cfg.Repo.ProtectedBranch == "" {
+		return state.RepositoryRecord{}, false, fmt.Errorf("repository state exists at %s but no repo record matches %s; run `mq repo init --repo %s` to repair it", store.Path, repoRoot, repoRoot)
+	}
+
+	record, err = store.UpsertRepository(ctx, state.RepositoryRecord{
+		CanonicalPath:   repoRoot,
+		ProtectedBranch: cfg.Repo.ProtectedBranch,
+		RemoteName:      cfg.Repo.RemoteName,
+		MainWorktree:    cfg.Repo.MainWorktree,
+		PolicyVersion:   "v1",
+	})
+	if err != nil {
+		return state.RepositoryRecord{}, false, err
+	}
+	return record, true, nil
+}

internal/app/repo.go

@@ -271,7 +271,7 @@ Flags:
 	ctx := context.Background()
 	var record state.RepositoryRecord
 	if store.Exists() {
-		if found, err := store.GetRepositoryByPath(ctx, repoRoot); err == nil {
+		if found, _, err := ensureRepositoryRecord(ctx, store, repoRoot, cfg); err == nil {
 			record = found
 		}
 	}
@@ -569,7 +569,7 @@ Flags:
 	var repoRecord state.RepositoryRecord
 	var hasRepoRecord bool
 	if store.Exists() {
-		if record, err := store.GetRepositoryByPath(ctx, repoRoot); err == nil {
+		if record, _, err := ensureRepositoryRecord(ctx, store, repoRoot, cfg); err == nil {
 			repoRecord = record
 			hasRepoRecord = true
 			count, err := store.CountUnfinishedItems(ctx, record.ID)

internal/app/repo_test.go

@@ -3,6 +3,7 @@ package app
 import (
 	"bytes"
 	"context"
+	"database/sql"
 	"encoding/json"
 	"os"
 	"os/exec"
@@ -55,6 +56,50 @@ func TestRepoInitAndShow(t *testing.T) {
 	}
 }
 
+func TestRepoShowRepairsMissingRepositoryRecord(t *testing.T) {
+	repoRoot, worktreePath := createTestRepo(t)
+
+	var initOut bytes.Buffer
+	var initErr bytes.Buffer
+	if err := runRepoInit([]string{"--repo", repoRoot, "--main-worktree", worktreePath}, &initOut, &initErr); err != nil {
+		t.Fatalf("runRepoInit returned error: %v", err)
+	}
+
+	layout, err := git.DiscoverRepositoryLayout(repoRoot)
+	if err != nil {
+		t.Fatalf("DiscoverRepositoryLayout: %v", err)
+	}
+	statePath := state.DefaultPath(layout.GitDir)
+	db, err := sql.Open("sqlite", statePath)
+	if err != nil {
+		t.Fatalf("sql.Open: %v", err)
+	}
+	defer db.Close()
+	if _, err := db.Exec(`DELETE FROM repositories`); err != nil {
+		t.Fatalf("DELETE repositories: %v", err)
+	}
+
+	var showOut bytes.Buffer
+	var showErr bytes.Buffer
+	if err := runRepoShow([]string{"--repo", repoRoot}, &showOut, &showErr); err != nil {
+		t.Fatalf("runRepoShow returned error: %v", err)
+	}
+
+	output := showOut.String()
+	if !strings.Contains(output, "State path: "+statePath) {
+		t.Fatalf("expected state path after record repair, got %q", output)
+	}
+
+	store := state.NewStore(statePath)
+	record, err := store.GetRepositoryByPath(context.Background(), layout.RepositoryRoot)
+	if err != nil {
+		t.Fatalf("GetRepositoryByPath after repair: %v", err)
+	}
+	if record.CanonicalPath != layout.RepositoryRoot {
+		t.Fatalf("expected repaired canonical path %q, got %+v", layout.RepositoryRoot, record)
+	}
+}
+
 func TestRepoInitSupportsJSONOutput(t *testing.T) {
 	repoRoot, worktreePath := createTestRepo(t)
 
@@ -115,6 +160,45 @@ func TestDoctorDetectsDirtyProtectedBranch(t *testing.T) {
 	}
 }
 
+func TestDoctorRepairsMissingRepositoryRecord(t *testing.T) {
+	repoRoot, worktreePath := createTestRepo(t)
+
+	var initOut bytes.Buffer
+	var initErr bytes.Buffer
+	if err := runRepoInit([]string{"--repo", repoRoot, "--main-worktree", worktreePath}, &initOut, &initErr); err != nil {
+		t.Fatalf("runRepoInit returned error: %v", err)
+	}
+
+	layout, err := git.DiscoverRepositoryLayout(repoRoot)
+	if err != nil {
+		t.Fatalf("DiscoverRepositoryLayout: %v", err)
+	}
+	statePath := state.DefaultPath(layout.GitDir)
+	db, err := sql.Open("sqlite", statePath)
+	if err != nil {
+		t.Fatalf("sql.Open: %v", err)
+	}
+	defer db.Close()
+	if _, err := db.Exec(`DELETE FROM repositories`); err != nil {
+		t.Fatalf("DELETE repositories: %v", err)
+	}
+
+	var doctorOut bytes.Buffer
+	var doctorErr bytes.Buffer
+	if err := runDoctor([]string{"--repo", repoRoot}, &doctorOut, &doctorErr); err != nil {
+		t.Fatalf("runDoctor returned error: %v", err)
+	}
+
+	store := state.NewStore(statePath)
+	record, err := store.GetRepositoryByPath(context.Background(), layout.RepositoryRoot)
+	if err != nil {
+		t.Fatalf("GetRepositoryByPath after doctor repair: %v", err)
+	}
+	if record.CanonicalPath != layout.RepositoryRoot {
+		t.Fatalf("expected repaired canonical path %q, got %+v", layout.RepositoryRoot, record)
+	}
+}
+
 func TestDoctorDetectsMissingCanonicalWorktree(t *testing.T) {
 	repoRoot, _ := createTestRepo(t)
 	missingWorktree := filepath.Join(repoRoot, "missing-main-worktree")