Merge pull request #9 from chojs23/allow-missing-base

Fix missing base chunk error when empty diff3 base with stage 1

Author: chojs23

internal/engine/base.go

@@ -23,7 +23,7 @@ func ValidateBaseCompleteness(doc markers.Document) error {
 		if !ok {
 			return fmt.Errorf("internal: conflict %d is not a ConflictSegment", i)
 		}
-		if len(seg.Base) == 0 {
+		if len(seg.Base) == 0 && seg.BaseLabel == "" {
 			return fmt.Errorf("conflict %d is missing base chunk (base display strategy requires exact base for all conflicts)", i)
 		}
 	}

internal/engine/base_test.go

@@ -70,6 +70,27 @@ func TestValidateBaseCompleteness_MissingBase(t *testing.T) {
 	}
 }
 
+func TestValidateBaseCompleteness_EmptyBaseBodyWithLabel(t *testing.T) {
+	doc := markers.Document{
+		Segments: []markers.Segment{
+			markers.ConflictSegment{
+				Ours:      []byte("ours\n"),
+				Base:      nil,
+				BaseLabel: "/tmp/base.txt",
+				Theirs:    []byte("theirs\n"),
+			},
+		},
+		Conflicts: []markers.ConflictRef{
+			{SegmentIndex: 0},
+		},
+	}
+
+	err := ValidateBaseCompleteness(doc)
+	if err != nil {
+		t.Fatalf("expected no error for empty base body with base label, got: %v", err)
+	}
+}
+
 // TestBaseDisplayIntegration_RealGitConflict creates a real git conflict using
 // temp git repos and validates that the diff3 view has base chunks for all conflicts.
 func TestBaseDisplayIntegration_RealGitConflict(t *testing.T) {

internal/run/select.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/chojs23/ec/internal/cli"
+	"github.com/chojs23/ec/internal/engine"
 	"github.com/chojs23/ec/internal/gitutil"
 	"github.com/chojs23/ec/internal/tui"
 )
@@ -120,7 +121,7 @@ func selectPath(paths []string) (string, error) {
 
 func selectPathInteractive(ctx context.Context, repoRoot string, paths []string) (string, error) {
 	if isInteractiveTTY() {
-		candidates, err := buildFileCandidates(ctx, repoRoot, paths)
+		candidates, err := buildFileCandidates(repoRoot, paths)
 		if err != nil {
 			return "", err
 		}
@@ -141,25 +142,23 @@ func isTTY(file *os.File) bool {
 	return (info.Mode() & os.ModeCharDevice) != 0
 }
 
-func buildFileCandidates(ctx context.Context, repoRoot string, paths []string) ([]tui.FileCandidate, error) {
+func buildFileCandidates(repoRoot string, paths []string) ([]tui.FileCandidate, error) {
 	candidates := make([]tui.FileCandidate, 0, len(paths))
 	for _, path := range paths {
-		resolved := !hasUnmergedStages(ctx, repoRoot, path)
+		mergedPath := path
+		if !filepath.IsAbs(mergedPath) {
+			mergedPath = filepath.Join(repoRoot, path)
+		}
+
+		resolved, err := engine.CheckResolvedFile(mergedPath)
+		if err != nil {
+			resolved = false
+		}
 		candidates = append(candidates, tui.FileCandidate{Path: path, Resolved: resolved})
 	}
 	return candidates, nil
 }
 
-func hasUnmergedStages(ctx context.Context, repoRoot string, path string) bool {
-	if _, err := gitutil.ShowStage(ctx, repoRoot, 2, path); err == nil {
-		return true
-	}
-	if _, err := gitutil.ShowStage(ctx, repoRoot, 3, path); err == nil {
-		return true
-	}
-	return false
-}
-
 func writeTempStages(base, local, remote []byte) (string, string, string, func(), error) {
 	baseFile, err := os.CreateTemp("", "ec-base-*")
 	if err != nil {

internal/run/select_test.go

@@ -116,15 +116,18 @@ func TestBuildFileCandidates(t *testing.T) {
 		t.Fatalf("write unresolved: %v", err)
 	}
 
-	candidates, err := buildFileCandidates(context.Background(), tmpDir, []string{"resolved.txt", "unresolved.txt"})
+	candidates, err := buildFileCandidates(tmpDir, []string{"resolved.txt", "unresolved.txt"})
 	if err != nil {
 		t.Fatalf("buildFileCandidates error: %v", err)
 	}
 	if len(candidates) != 2 {
 		t.Fatalf("candidates len = %d, want 2", len(candidates))
 	}
-	if !candidates[0].Resolved || !candidates[1].Resolved {
-		t.Fatalf("expected non-repo candidates to default to resolved status")
+	if !candidates[0].Resolved {
+		t.Fatalf("expected marker-free file to be resolved")
+	}
+	if candidates[1].Resolved {
+		t.Fatalf("expected marker-containing file to be unresolved")
 	}
 }
 
@@ -172,15 +175,69 @@ func TestBuildFileCandidatesDoesNotFailOnMalformedMergedFile(t *testing.T) {
 		t.Fatalf("write malformed conflict file: %v", err)
 	}
 
-	candidates, err := buildFileCandidates(context.Background(), repoDir, []string{"conflict.txt"})
+	candidates, err := buildFileCandidates(repoDir, []string{"conflict.txt"})
 	if err != nil {
 		t.Fatalf("buildFileCandidates error: %v", err)
 	}
 	if len(candidates) != 1 {
 		t.Fatalf("candidates len = %d, want 1", len(candidates))
 	}
 	if candidates[0].Resolved {
-		t.Fatalf("expected malformed merged conflict to remain unresolved based on index stages")
+		t.Fatalf("expected malformed merged conflict to remain unresolved")
+	}
+}
+
+func TestBuildFileCandidatesResolvedFromMergedContentWithoutGitAdd(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping git integration test in short mode")
+	}
+	if _, err := exec.LookPath("git"); err != nil {
+		t.Skip("git not found in PATH")
+	}
+
+	repoDir := t.TempDir()
+	runGit(t, repoDir, "init")
+	runGit(t, repoDir, "config", "user.email", "test@example.com")
+	runGit(t, repoDir, "config", "user.name", "Test User")
+
+	conflictPath := filepath.Join(repoDir, "conflict.txt")
+	if err := os.WriteFile(conflictPath, []byte("a\nZ\nb\n"), 0o644); err != nil {
+		t.Fatalf("write base: %v", err)
+	}
+	runGit(t, repoDir, "add", "conflict.txt")
+	runGit(t, repoDir, "commit", "-m", "base")
+
+	runGit(t, repoDir, "checkout", "-b", "feature")
+	if err := os.WriteFile(conflictPath, []byte("a\nY\nZ\nb\n"), 0o644); err != nil {
+		t.Fatalf("write theirs: %v", err)
+	}
+	runGit(t, repoDir, "commit", "-am", "theirs")
+
+	runGit(t, repoDir, "checkout", "-")
+	if err := os.WriteFile(conflictPath, []byte("a\nX\nZ\nb\n"), 0o644); err != nil {
+		t.Fatalf("write ours: %v", err)
+	}
+	runGit(t, repoDir, "commit", "-am", "ours")
+
+	mergeCmd := exec.Command("git", "merge", "feature")
+	mergeCmd.Dir = repoDir
+	if output, err := mergeCmd.CombinedOutput(); err == nil {
+		t.Fatalf("expected merge conflict, got success: %s", string(output))
+	}
+
+	if err := os.WriteFile(conflictPath, []byte("a\nX\nZ\nb\n"), 0o644); err != nil {
+		t.Fatalf("write resolved content: %v", err)
+	}
+
+	candidates, err := buildFileCandidates(repoDir, []string{"conflict.txt"})
+	if err != nil {
+		t.Fatalf("buildFileCandidates error: %v", err)
+	}
+	if len(candidates) != 1 {
+		t.Fatalf("candidates len = %d, want 1", len(candidates))
+	}
+	if !candidates[0].Resolved {
+		t.Fatalf("expected resolved merged content to be shown as resolved without git add")
 	}
 }