Add wl merge command to land reviewed branches into main

Merges a wl/* branch into main, pushes to upstream+origin, and deletes
the branch by default. Supports --keep-branch and --no-push. Detects
merge conflicts and aborts cleanly with a helpful message.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: julianknutsen

cmd/wl/cmd_merge.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/spf13/cobra"
+	"github.com/steveyegge/wasteland/internal/commons"
+	"github.com/steveyegge/wasteland/internal/style"
+)
+
+func newMergeCmd(stdout, stderr io.Writer) *cobra.Command {
+	var (
+		noPush     bool
+		keepBranch bool
+	)
+
+	cmd := &cobra.Command{
+		Use:   "merge <branch>",
+		Short: "Merge a reviewed branch into main",
+		Long: `Merge a wl/* branch into main after review.
+
+Performs a Dolt merge, pushes main to upstream and origin, and deletes
+the branch (unless --keep-branch is set).
+
+Examples:
+  wl merge wl/my-rig/w-abc123
+  wl merge wl/my-rig/w-abc123 --keep-branch
+  wl merge wl/my-rig/w-abc123 --no-push`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cmd *cobra.Command, args []string) error {
+			return runMerge(cmd, stdout, stderr, args[0], noPush, keepBranch)
+		},
+	}
+
+	cmd.Flags().BoolVar(&noPush, "no-push", false, "Skip pushing to remotes")
+	cmd.Flags().BoolVar(&keepBranch, "keep-branch", false, "Don't delete branch after merge")
+
+	return cmd
+}
+
+func runMerge(cmd *cobra.Command, stdout, _ io.Writer, branch string, noPush, keepBranch bool) error {
+	cfg, err := resolveWasteland(cmd)
+	if err != nil {
+		return fmt.Errorf("loading wasteland config: %w", err)
+	}
+
+	exists, err := commons.BranchExists(cfg.LocalDir, branch)
+	if err != nil {
+		return fmt.Errorf("checking branch: %w", err)
+	}
+	if !exists {
+		return fmt.Errorf("branch %q does not exist", branch)
+	}
+
+	if err := commons.MergeBranch(cfg.LocalDir, branch); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(stdout, "%s Merged %s into main\n", style.Bold.Render("✓"), branch)
+
+	if !keepBranch {
+		if err := commons.DeleteBranch(cfg.LocalDir, branch); err != nil {
+			fmt.Fprintf(stdout, "  warning: failed to delete branch %s: %v\n", branch, err)
+		} else {
+			fmt.Fprintf(stdout, "  Branch %s deleted\n", branch)
+		}
+	}
+
+	if !noPush {
+		_ = commons.PushWithSync(cfg.LocalDir, stdout)
+	}
+
+	return nil
+}

cmd/wl/cmd_merge_test.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestMergeRequiresArg(t *testing.T) {
+	var stdout, stderr bytes.Buffer
+	root := newRootCmd(&stdout, &stderr)
+
+	for _, c := range root.Commands() {
+		if c.Name() == "merge" {
+			if err := c.Args(c, []string{}); err == nil {
+				t.Error("merge should require exactly 1 argument")
+			}
+			if err := c.Args(c, []string{"wl/rig/w-abc"}); err != nil {
+				t.Errorf("merge should accept 1 argument: %v", err)
+			}
+			if err := c.Args(c, []string{"a", "b"}); err == nil {
+				t.Error("merge should reject 2 arguments")
+			}
+			return
+		}
+	}
+	t.Fatal("merge command not found")
+}

cmd/wl/main.go

@@ -79,6 +79,7 @@ func newRootCmd(stdout, stderr io.Writer) *cobra.Command {
 		newListCmd(stdout, stderr),
 		newConfigCmd(stdout, stderr),
 		newReviewCmd(stdout, stderr),
+		newMergeCmd(stdout, stderr),
 		newVersionCmd(stdout),
 	)
 	return root

cmd/wl/main_test.go

@@ -28,7 +28,7 @@ func TestSubcommandRegistration(t *testing.T) {
 	var stdout, stderr bytes.Buffer
 	root := newRootCmd(&stdout, &stderr)
 
-	expected := []string{"join", "post", "claim", "unclaim", "done", "accept", "reject", "update", "delete", "browse", "status", "sync", "leave", "list", "config", "review", "version"}
+	expected := []string{"join", "post", "claim", "unclaim", "done", "accept", "reject", "update", "delete", "browse", "status", "sync", "leave", "list", "config", "review", "merge", "version"}
 	for _, name := range expected {
 		found := false
 		for _, c := range root.Commands() {

cmd/wl/testdata/errors.txtar

@@ -146,6 +146,14 @@ stderr 'not joined'
 ! exec wl review wl/some/branch
 stderr 'not joined'
 
+# merge with no args.
+! exec wl merge
+stderr 'accepts 1 arg'
+
+# merge not joined.
+! exec wl merge wl/some/branch
+stderr 'not joined'
+
 # config get not joined.
 ! exec wl config get mode
 stderr 'not joined'

internal/commons/dolt.go

@@ -174,6 +174,29 @@ func ListBranches(dbDir, prefix string) ([]string, error) {
 	return branches, nil
 }
 
+// MergeBranch merges a branch into main. If the merge produces conflicts
+// it aborts and returns an error. The caller must already be on main.
+func MergeBranch(dbDir, branch string) error {
+	escaped := strings.ReplaceAll(branch, "'", "''")
+	err := doltSQLScript(dbDir, fmt.Sprintf(
+		"CALL DOLT_CHECKOUT('main');\nCALL DOLT_MERGE('%s');", escaped,
+	))
+	if err != nil {
+		if strings.Contains(strings.ToLower(err.Error()), "conflict") {
+			_ = doltSQLScript(dbDir, "CALL DOLT_MERGE('--abort');")
+			return fmt.Errorf("merge conflict on branch %s: resolve manually or delete the branch", branch)
+		}
+		return fmt.Errorf("merging branch %s: %w", branch, err)
+	}
+	return nil
+}
+
+// DeleteBranch deletes a local branch.
+func DeleteBranch(dbDir, branch string) error {
+	escaped := strings.ReplaceAll(branch, "'", "''")
+	return doltSQLScript(dbDir, fmt.Sprintf("CALL DOLT_BRANCH('-D', '%s');", escaped))
+}
+
 // doltSQLQuery executes a SQL query and returns the raw CSV output.
 func doltSQLQuery(dbDir, query string) (string, error) {
 	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)

test/integration/offline/pr_mode_test.go

@@ -242,6 +242,158 @@ func TestReviewShowsDiff(t *testing.T) {
 	}
 }
 
+func TestMergeBasic(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+			dbDir := forkCloneDir(t, env)
+
+			// Switch to PR mode and post.
+			setMode(t, env, upstream, "pr")
+
+			stdout, _, err := runWL(t, env, "post",
+				"--title", "Merge test item",
+				"--type", "feature",
+				"--no-push",
+			)
+			if err != nil {
+				t.Fatalf("wl post failed: %v", err)
+			}
+			wantedID := extractWantedID(t, stdout)
+			branch := "wl/" + forkOrg + "/" + wantedID
+
+			// Item should NOT be on main yet.
+			raw := doltSQL(t, dbDir, "SELECT COUNT(*) FROM wanted WHERE id='"+wantedID+"'")
+			rows := parseCSV(t, raw)
+			if len(rows) >= 2 && strings.TrimSpace(rows[1][0]) != "0" {
+				t.Errorf("item should not be on main before merge, got count: %s", rows[1][0])
+			}
+
+			// Merge.
+			stdout, stderr, err := runWL(t, env, "merge", branch, "--no-push")
+			if err != nil {
+				t.Fatalf("wl merge failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+			if !strings.Contains(stdout, "Merged") {
+				t.Errorf("expected 'Merged' message, got: %s", stdout)
+			}
+			if !strings.Contains(stdout, "deleted") {
+				t.Errorf("expected branch deletion message, got: %s", stdout)
+			}
+
+			// Item should now be on main.
+			raw = doltSQL(t, dbDir, "SELECT id, title FROM wanted WHERE id='"+wantedID+"'")
+			rows = parseCSV(t, raw)
+			if len(rows) < 2 {
+				t.Fatalf("wanted item %s not found on main after merge", wantedID)
+			}
+			if rows[1][1] != "Merge test item" {
+				t.Errorf("title = %q, want %q", rows[1][1], "Merge test item")
+			}
+
+			// Branch should be gone.
+			raw = doltSQL(t, dbDir, "SELECT COUNT(*) FROM dolt_branches WHERE name='"+branch+"'")
+			rows = parseCSV(t, raw)
+			if len(rows) >= 2 && strings.TrimSpace(rows[1][0]) != "0" {
+				t.Errorf("branch %s should be deleted after merge", branch)
+			}
+		})
+	}
+}
+
+func TestMergeKeepBranch(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+			dbDir := forkCloneDir(t, env)
+
+			setMode(t, env, upstream, "pr")
+
+			stdout, _, err := runWL(t, env, "post",
+				"--title", "Keep branch test",
+				"--type", "bug",
+				"--no-push",
+			)
+			if err != nil {
+				t.Fatalf("wl post failed: %v", err)
+			}
+			wantedID := extractWantedID(t, stdout)
+			branch := "wl/" + forkOrg + "/" + wantedID
+
+			// Merge with --keep-branch.
+			stdout, stderr, err := runWL(t, env, "merge", branch, "--keep-branch", "--no-push")
+			if err != nil {
+				t.Fatalf("wl merge failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			// Branch should still exist.
+			raw := doltSQL(t, dbDir, "SELECT COUNT(*) FROM dolt_branches WHERE name='"+branch+"'")
+			rows := parseCSV(t, raw)
+			if len(rows) < 2 || strings.TrimSpace(rows[1][0]) != "1" {
+				t.Errorf("branch %s should still exist with --keep-branch", branch)
+			}
+		})
+	}
+}
+
+func TestMergeNonExistentBranch(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+
+			_, _, err := runWL(t, env, "merge", "wl/fake/w-nonexistent", "--no-push")
+			if err == nil {
+				t.Fatal("merge of non-existent branch should fail")
+			}
+		})
+	}
+}
+
+func TestMergeFullLifecycle(t *testing.T) {
+	for _, backend := range backends {
+		t.Run(string(backend), func(t *testing.T) {
+			env := joinedEnv(t, backend)
+			dbDir := forkCloneDir(t, env)
+
+			// PR mode: post → review --stat → merge → verify on main.
+			setMode(t, env, upstream, "pr")
+
+			stdout, _, err := runWL(t, env, "post",
+				"--title", "Full lifecycle PR",
+				"--type", "feature",
+				"--no-push",
+			)
+			if err != nil {
+				t.Fatalf("wl post failed: %v", err)
+			}
+			wantedID := extractWantedID(t, stdout)
+			branch := "wl/" + forkOrg + "/" + wantedID
+
+			// Review should show diff.
+			stdout, stderr, err := runWL(t, env, "review", branch, "--stat")
+			if err != nil {
+				t.Fatalf("wl review --stat failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+			if !strings.Contains(stdout, "wanted") {
+				t.Errorf("review stat should mention 'wanted', got: %s", stdout)
+			}
+
+			// Merge.
+			stdout, stderr, err = runWL(t, env, "merge", branch, "--no-push")
+			if err != nil {
+				t.Fatalf("wl merge failed: %v\nstdout: %s\nstderr: %s", err, stdout, stderr)
+			}
+
+			// Verify on main.
+			raw := doltSQL(t, dbDir, "SELECT title FROM wanted WHERE id='"+wantedID+"'")
+			rows := parseCSV(t, raw)
+			if len(rows) < 2 || rows[1][0] != "Full lifecycle PR" {
+				t.Errorf("item not found on main after merge")
+			}
+		})
+	}
+}
+
 func TestConfigSetGetMode(t *testing.T) {
 	for _, backend := range backends {
 		t.Run(string(backend), func(t *testing.T) {