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

Fix : Allow missing base

Author: chojs23

internal/run/select.go

@@ -11,7 +11,6 @@ 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"
 )
@@ -121,7 +120,7 @@ func selectPath(paths []string) (string, error) {
 
 func selectPathInteractive(ctx context.Context, repoRoot string, paths []string) (string, error) {
 	if isInteractiveTTY() {
-		candidates, err := buildFileCandidates(repoRoot, paths)
+		candidates, err := buildFileCandidates(ctx, repoRoot, paths)
 		if err != nil {
 			return "", err
 		}
@@ -142,22 +141,25 @@ func isTTY(file *os.File) bool {
 	return (info.Mode() & os.ModeCharDevice) != 0
 }
 
-func buildFileCandidates(repoRoot string, paths []string) ([]tui.FileCandidate, error) {
+func buildFileCandidates(ctx context.Context, repoRoot string, paths []string) ([]tui.FileCandidate, error) {
 	candidates := make([]tui.FileCandidate, 0, len(paths))
 	for _, path := range paths {
-		mergedPath := path
-		if !filepath.IsAbs(mergedPath) {
-			mergedPath = filepath.Join(repoRoot, path)
-		}
-		resolved, err := engine.CheckResolvedFile(mergedPath)
-		if err != nil {
-			return nil, fmt.Errorf("check resolved %s: %w", path, err)
-		}
+		resolved := !hasUnmergedStages(ctx, repoRoot, path)
 		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,18 +116,71 @@ func TestBuildFileCandidates(t *testing.T) {
 		t.Fatalf("write unresolved: %v", err)
 	}
 
-	candidates, err := buildFileCandidates(tmpDir, []string{"resolved.txt", "unresolved.txt"})
+	candidates, err := buildFileCandidates(context.Background(), 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 {
-		t.Fatalf("resolved file marked unresolved")
+	if !candidates[0].Resolved || !candidates[1].Resolved {
+		t.Fatalf("expected non-repo candidates to default to resolved status")
 	}
-	if candidates[1].Resolved {
-		t.Fatalf("unresolved file marked resolved")
+}
+
+func TestBuildFileCandidatesDoesNotFailOnMalformedMergedFile(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("base\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("theirs\n"), 0o644); err != nil {
+		t.Fatalf("write theirs: %v", err)
+	}
+	runGit(t, repoDir, "add", "conflict.txt")
+	runGit(t, repoDir, "commit", "-m", "theirs")
+
+	runGit(t, repoDir, "checkout", "-")
+	if err := os.WriteFile(conflictPath, []byte("ours\n"), 0o644); err != nil {
+		t.Fatalf("write ours: %v", err)
+	}
+	runGit(t, repoDir, "add", "conflict.txt")
+	runGit(t, repoDir, "commit", "-m", "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("<<<<<<< HEAD\nours\n=======\ntheirs\n>>>>\n"), 0o644); err != nil {
+		t.Fatalf("write malformed conflict file: %v", err)
+	}
+
+	candidates, err := buildFileCandidates(context.Background(), 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")
 	}
 }
 

internal/tui/tui.go

@@ -17,6 +17,7 @@ import (
 	"github.com/chojs23/ec/internal/cli"
 	"github.com/chojs23/ec/internal/engine"
 	"github.com/chojs23/ec/internal/gitmerge"
+	"github.com/chojs23/ec/internal/gitutil"
 	"github.com/chojs23/ec/internal/markers"
 )
 
@@ -222,7 +223,11 @@ func Run(ctx context.Context, opts cli.Options) error {
 	// Validate base completeness unless explicitly allowed to proceed without it.
 	if !opts.AllowMissingBase {
 		if err := engine.ValidateBaseCompleteness(doc); err != nil {
-			return fmt.Errorf("base validation failed: %w", err)
+			if shouldAllowMissingBaseFallback(ctx, opts, err) {
+				opts.AllowMissingBase = true
+			} else {
+				return fmt.Errorf("base validation failed: %w", err)
+			}
 		}
 	}
 
@@ -361,8 +366,14 @@ func (m *model) reloadFromFile() error {
 		return fmt.Errorf("parse diff3 view: %w", err)
 	}
 
-	if err := engine.ValidateBaseCompleteness(doc); err != nil {
-		return fmt.Errorf("base validation failed: %w", err)
+	if !m.opts.AllowMissingBase {
+		if err := engine.ValidateBaseCompleteness(doc); err != nil {
+			if shouldAllowMissingBaseFallback(m.ctx, m.opts, err) {
+				m.opts.AllowMissingBase = true
+			} else {
+				return fmt.Errorf("base validation failed: %w", err)
+			}
+		}
 	}
 
 	updated, manual, err := applyMergedResolutions(doc, editedBytes)
@@ -414,6 +425,76 @@ func prepareFullDiff(doc markers.Document, opts cli.Options) ([]string, []string
 	return baseLines, oursLines, theirsLines, ranges, true
 }
 
+func shouldAllowMissingBaseFallback(ctx context.Context, opts cli.Options, validationErr error) bool {
+	if validationErr == nil || !strings.Contains(validationErr.Error(), "missing base chunk") {
+		return false
+	}
+	if !isTrulyMissingBasePath(opts.BasePath) {
+		return false
+	}
+
+	missingStage, determined := isTrulyMissingBaseStage(ctx, opts.MergedPath)
+	if determined {
+		return missingStage
+	}
+
+	return true
+}
+
+func isTrulyMissingBasePath(basePath string) bool {
+	if basePath == "" {
+		return false
+	}
+	if basePath == os.DevNull {
+		return true
+	}
+
+	info, err := os.Stat(basePath)
+	if err != nil {
+		return false
+	}
+
+	return info.Size() == 0
+}
+
+func isTrulyMissingBaseStage(ctx context.Context, mergedPath string) (bool, bool) {
+	if mergedPath == "" {
+		return false, false
+	}
+
+	absMergedPath, err := filepath.Abs(mergedPath)
+	if err != nil {
+		return false, false
+	}
+
+	repoRoot, err := gitutil.RepoRoot(ctx, filepath.Dir(absMergedPath))
+	if err != nil {
+		return false, false
+	}
+
+	relPath, err := filepath.Rel(repoRoot, absMergedPath)
+	if err != nil {
+		return false, false
+	}
+	if relPath == ".." || strings.HasPrefix(relPath, ".."+string(filepath.Separator)) {
+		return false, false
+	}
+	relPath = filepath.ToSlash(relPath)
+
+	if _, err := gitutil.ShowStage(ctx, repoRoot, 2, relPath); err != nil {
+		return false, false
+	}
+	if _, err := gitutil.ShowStage(ctx, repoRoot, 3, relPath); err != nil {
+		return false, false
+	}
+
+	if _, err := gitutil.ShowStage(ctx, repoRoot, 1, relPath); err != nil {
+		return true, true
+	}
+
+	return false, true
+}
+
 func loadLines(path string) ([]string, error) {
 	bytes, err := os.ReadFile(path)
 	if err != nil {