`a943129`

S22: pulls orchestrator (create/sync/mergeability/merge/state) + tests

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 5 days ago

SHA: a943129c730b7fc50b3097bb05ed3e63b1d4fed3
Parents: 5d8e910
Tree: a68b3cf

6 changed files

Status	File	+
A	`internal/pulls/linked_issues.go`	39
A	`internal/pulls/linked_issues_test.go`	34
A	`internal/pulls/merge.go`	244
A	`internal/pulls/pulls.go`	377
A	`internal/pulls/pulls_test.go`	366
A	`internal/pulls/state.go`	47

internal/pulls/linked_issues.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package pulls
++
 +import (
 +	"regexp"
 +	"strconv"
 +)
++
 +// reLinkedIssue matches the GitHub-style auto-close keywords:
 +//
 +//	close|closes|closed | fix|fixes|fixed | resolve|resolves|resolved
 +//
 +// followed by `#N`. Case-insensitive. The keyword + `#N` must be a
 +// connected token (one space allowed) so plain "...closes the door
 +// on #5..." doesn't accidentally trigger an auto-close.
 +var reLinkedIssue = regexp.MustCompile(`(?i)\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+#([0-9]{1,9})\b`)
++
 +// parseLinkedIssues returns the deduplicated set of issue numbers a
 +// PR body or commit message intends to auto-close.
 +func parseLinkedIssues(body string) []int64 {
 +	if body == "" {
 +		return nil
 +	}
 +	seen := map[int64]struct{}{}
 +	out := []int64{}
 +	for _, m := range reLinkedIssue.FindAllStringSubmatch(body, -1) {
 +		n, err := strconv.ParseInt(m[1], 10, 64)
 +		if err != nil {
 +			continue
 +		}
 +		if _, dup := seen[n]; dup {
 +			continue
 +		}
 +		seen[n] = struct{}{}
 +		out = append(out, n)
 +	}
 +	return out
 +}

internal/pulls/linked_issues_test.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package pulls
++
 +import (
 +	"reflect"
 +	"testing"
 +)
++
 +func TestParseLinkedIssues(t *testing.T) {
 +	t.Parallel()
 +	cases := []struct {
 +		name string
 +		body string
 +		want []int64
 +	}{
 +		{"closes", "closes #1", []int64{1}},
 +		{"fixes_capitalized", "Fixes #42", []int64{42}},
 +		{"resolves_past_tense", "Resolved #7", []int64{7}},
 +		{"multiple", "Closes #1, fixes #2, resolves #3", []int64{1, 2, 3}},
 +		{"dedup", "Fixes #5\nFixes #5 again", []int64{5}},
 +		{"plain_hash_does_not_match", "see #99 — does not auto-close", nil},
 +		{"keyword_in_prose_no_hash", "this closes the door on bug fixes", nil},
 +		{"fixed_with_extra_whitespace", "Fixed  #11", []int64{11}},
 +	}
 +	for _, c := range cases {
 +		t.Run(c.name, func(t *testing.T) {
 +			got := parseLinkedIssues(c.body)
 +			if !reflect.DeepEqual(got, c.want) && !(len(got) == 0 && len(c.want) == 0) {
 +				t.Errorf("body %q: got %v, want %v", c.body, got, c.want)
 +			}
 +		})
 +	}
 +}

internal/pulls/merge.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package pulls
++
 +import (
 +	"context"
 +	"errors"
 +	"fmt"
 +	"strconv"
 +	"strings"
 +	"time"
++
 +	"github.com/jackc/pgx/v5/pgtype"
++
 +	"github.com/tenseleyFlow/shithub/internal/issues"
 +	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"
 +	pullsdb "github.com/tenseleyFlow/shithub/internal/pulls/sqlc"
 +	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"
 +	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"
 +)
++
 +// MergeParams describes a merge request.
 +type MergeParams struct {
 +	PRID         int64
 +	ActorUserID  int64
 +	GitDir       string
 +	Method       string // "merge" | "squash" | "rebase"
 +	Subject      string // optional override; falls back to "<title> (#<number>)"
 +	Body         string
 +	WorktreesDir string // optional, defaults to <gitDir>/.tmp-worktrees
 +	Now          func() time.Time
 +}
++
 +// Merge performs the requested merge inside a temp worktree:
 +//
 +//  1. Lock the pull_requests row (FOR UPDATE) to serialize concurrent
 +//     attempts. The transaction holds for the whole job to keep the
 +//     lock until the DB state reflects the merge.
 +//  2. Validate state: not merged, not closed, mergeable_state == clean,
 +//     method allowed by the repo config.
 +//  3. Resolve identity (author = PR author for squash, merger otherwise;
 +//     committer = merger).
 +//  4. Run repogit.PerformMerge against the bare repo.
 +//  5. Persist merge_commit_sha + merged_at + flip the issue to closed
 +//     with state_reason='completed'.
 +//  6. Auto-close linked issues parsed from PR body + commit messages.
 +//  7. Emit a `merged` timeline event.
 +func Merge(ctx context.Context, deps Deps, p MergeParams) error {
 +	if p.Now == nil {
 +		p.Now = time.Now
 +	}
++
 +	// Begin the locking tx. Holding the row lock through the whole
 +	// merge prevents two attempts both winning at the worktree level.
 +	tx, err := deps.Pool.Begin(ctx)
 +	if err != nil {
 +		return err
 +	}
 +	committed := false
 +	defer func() {
 +		if !committed {
 +			_ = tx.Rollback(ctx)
 +		}
 +	}()
++
 +	q := pullsdb.New()
 +	pr, err := q.LockPullRequestForMerge(ctx, tx, p.PRID)
 +	if err != nil {
 +		return ErrPRNotFound
 +	}
 +	if pr.MergedAt.Valid {
 +		return ErrAlreadyMerged
 +	}
 +	// Issue side: must still be open + mergeable.
 +	iq := issuesdb.New()
 +	issue, err := iq.GetIssueByID(ctx, tx, p.PRID)
 +	if err != nil {
 +		return err
 +	}
 +	if issue.State != issuesdb.IssueStateOpen {
 +		return ErrAlreadyClosed
 +	}
 +	if pr.MergeableState != pullsdb.PrMergeableStateClean {
 +		return ErrMergeBlocked
 +	}
++
 +	// Identity for the new commit. Author email rules per spec:
 +	//   merge       — author = committer = merger
 +	//   squash      — author = PR author; committer = merger
 +	//   rebase      — author preserved; committer = merger (handled by
 +	//                 repogit.PerformMerge via env)
 +	uq := usersdb.New()
 +	mergerName, mergerEmail, err := identityFor(ctx, tx, uq, p.ActorUserID)
 +	if err != nil {
 +		return err
 +	}
 +	authorName, authorEmail := mergerName, mergerEmail
 +	if p.Method == "squash" && issue.AuthorUserID.Valid {
 +		an, ae, err := identityFor(ctx, tx, uq, issue.AuthorUserID.Int64)
 +		if err == nil {
 +			authorName, authorEmail = an, ae
 +		}
 +	}
++
 +	subject := strings.TrimSpace(p.Subject)
 +	if subject == "" {
 +		subject = issue.Title + " (#" + strconv.FormatInt(issue.Number, 10) + ")"
 +	}
++
 +	// Run the merge against the bare repo. PerformMerge cleans up the
 +	// worktree on every exit path.
 +	mergeRes, err := repogit.PerformMerge(ctx, repogit.MergeOptions{
 +		GitDir:         p.GitDir,
 +		BaseRef:        "refs/heads/" + pr.BaseRef,
 +		BaseOID:        pr.BaseOid,
 +		HeadOID:        pr.HeadOid,
 +		Method:         p.Method,
 +		AuthorName:     authorName,
 +		AuthorEmail:    authorEmail,
 +		CommitterName:  mergerName,
 +		CommitterEmail: mergerEmail,
 +		When:           p.Now(),
 +		Subject:        subject,
 +		Body:           p.Body,
 +		WorktreesDir:   p.WorktreesDir,
 +	})
 +	if err != nil {
 +		return fmt.Errorf("perform merge: %w", err)
 +	}
++
 +	if err := q.SetPullRequestMerged(ctx, tx, pullsdb.SetPullRequestMergedParams{
 +		IssueID:         p.PRID,
 +		MergedByUserID:  pgtype.Int8{Int64: p.ActorUserID, Valid: p.ActorUserID != 0},
 +		MergeCommitSha:  pgtype.Text{String: mergeRes.MergedOID, Valid: true},
 +		MergeMethod:     pullsdb.NullPrMergeMethod{PrMergeMethod: pullsdb.PrMergeMethod(p.Method), Valid: true},
 +		BaseOidAtMerge:  pgtype.Text{String: pr.BaseOid, Valid: true},
 +		HeadOidAtMerge:  pgtype.Text{String: pr.HeadOid, Valid: true},
 +	}); err != nil {
 +		return err
 +	}
++
 +	// Close the issue side with state_reason=completed.
 +	if err := iq.SetIssueState(ctx, tx, issuesdb.SetIssueStateParams{
 +		ID:             p.PRID,
 +		State:          issuesdb.IssueStateClosed,
 +		StateReason:    issuesdb.NullIssueStateReason{IssueStateReason: issuesdb.IssueStateReasonCompleted, Valid: true},
 +		ClosedByUserID: pgtype.Int8{Int64: p.ActorUserID, Valid: p.ActorUserID != 0},
 +	}); err != nil {
 +		return err
 +	}
++
 +	// `merged` timeline event.
 +	if _, err := iq.InsertIssueEvent(ctx, tx, issuesdb.InsertIssueEventParams{
 +		IssueID:     p.PRID,
 +		ActorUserID: pgtype.Int8{Int64: p.ActorUserID, Valid: p.ActorUserID != 0},
 +		Kind:        "merged",
 +		Meta:        []byte(fmt.Sprintf(`{"method":%q,"commit":%q}`, p.Method, mergeRes.MergedOID)),
 +	}); err != nil {
 +		return err
 +	}
++
 +	// Auto-close linked issues. Linked = Closes/Fixes/Resolves #N in
 +	// the PR body + each commit message. Best-effort; don't fail the
 +	// merge if the close fails.
 +	linked := parseLinkedIssues(issue.Body)
 +	for _, c := range fetchCommitsForLinkScan(ctx, tx, p.PRID) {
 +		linked = append(linked, parseLinkedIssues(c)...)
 +	}
 +	closed := map[int64]bool{}
 +	for _, num := range linked {
 +		if num == issue.Number {
 +			continue // self-reference
 +		}
 +		target, err := iq.GetIssueByNumber(ctx, tx, issuesdb.GetIssueByNumberParams{
 +			RepoID: issue.RepoID, Number: num,
 +		})
 +		if err != nil || target.Kind != issuesdb.IssueKindIssue || target.State != issuesdb.IssueStateOpen {
 +			continue
 +		}
 +		if closed[target.ID] {
 +			continue
 +		}
 +		closed[target.ID] = true
 +		_ = iq.SetIssueState(ctx, tx, issuesdb.SetIssueStateParams{
 +			ID:             target.ID,
 +			State:          issuesdb.IssueStateClosed,
 +			StateReason:    issuesdb.NullIssueStateReason{IssueStateReason: issuesdb.IssueStateReasonCompleted, Valid: true},
 +			ClosedByUserID: pgtype.Int8{Int64: p.ActorUserID, Valid: p.ActorUserID != 0},
 +		})
 +		_, _ = iq.InsertIssueEvent(ctx, tx, issuesdb.InsertIssueEventParams{
 +			IssueID:     target.ID,
 +			ActorUserID: pgtype.Int8{Int64: p.ActorUserID, Valid: p.ActorUserID != 0},
 +			Kind:        "closed",
 +			Meta:        []byte(fmt.Sprintf(`{"closed_by_pr":%d}`, p.PRID)),
 +		})
 +	}
++
 +	if err := tx.Commit(ctx); err != nil {
 +		return err
 +	}
 +	committed = true
 +	return nil
 +}
++
 +// identityFor reads the user's display + primary verified email for
 +// commit identity. Falls back to a synthesised noreply on missing data
 +// rather than failing the merge — privacy/noreply emails ship post-MVP.
 +func identityFor(ctx context.Context, db pullsdb.DBTX, uq *usersdb.Queries, userID int64) (name, email string, err error) {
 +	user, err := uq.GetUserByID(ctx, db, userID)
 +	if err != nil {
 +		return "", "", err
 +	}
 +	display := strings.TrimSpace(user.DisplayName)
 +	if display == "" {
 +		display = user.Username
 +	}
 +	addr := user.Username + "@noreply.shithub.local"
 +	if user.PrimaryEmailID.Valid {
 +		em, err := uq.GetUserEmailByID(ctx, db, user.PrimaryEmailID.Int64)
 +		if err == nil && em.Verified {
 +			addr = string(em.Email)
 +		}
 +	}
 +	return display, addr, nil
 +}
++
 +// fetchCommitsForLinkScan returns the head-side commit messages so the
 +// linked-issue parser can scan body + subject. Best-effort — returns
 +// an empty slice on error.
 +func fetchCommitsForLinkScan(ctx context.Context, db pullsdb.DBTX, prID int64) []string {
 +	rows, err := pullsdb.New().ListPullRequestCommits(ctx, db, prID)
 +	if err != nil {
 +		return nil
 +	}
 +	out := make([]string, 0, len(rows))
 +	for _, r := range rows {
 +		out = append(out, r.Subject+"\n\n"+r.Body)
 +	}
 +	return out
 +}
++
 +// Compile-time check that issues' typed errors are still in scope so
 +// EditPR's wrapping continues to work after refactors.
 +var _ = errors.Is(issues.ErrEmptyTitle, issues.ErrEmptyTitle)

internal/pulls/pulls.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +// Package pulls owns the pull-request orchestrator. PRs reuse the S21
 +// `issues` row for title/body/state/timeline; this package owns the
 +// PR-specific surface — opening, synchronizing, mergeability detection,
 +// merge execution.
 +//
 +// Entry points are:
 +//
 +//	Create     — opens a PR (creates the issue row + the pull_requests row)
 +//	Synchronize — refreshes commit + file lists + emits a synchronized event
 +//	Mergeability — recomputes mergeable / mergeable_state via merge-tree
 +//	Merge      — performs the requested merge strategy in a temp worktree
 +//	Edit       — title/body
 +//	SetState   — close / reopen
 +//	SetReady   — draft → ready
 +package pulls
++
 +import (
 +	"context"
 +	"errors"
 +	"fmt"
 +	"log/slog"
 +	"strings"
++
 +	"github.com/jackc/pgx/v5"
 +	"github.com/jackc/pgx/v5/pgtype"
 +	"github.com/jackc/pgx/v5/pgxpool"
++
 +	"github.com/tenseleyFlow/shithub/internal/issues"
 +	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"
 +	pullsdb "github.com/tenseleyFlow/shithub/internal/pulls/sqlc"
 +	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"
 +	mdrender "github.com/tenseleyFlow/shithub/internal/repos/markdown"
 +	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"
 +)
++
 +// Deps wires this package against the rest of the runtime.
 +type Deps struct {
 +	Pool   *pgxpool.Pool
 +	Logger *slog.Logger
 +}
++
 +// Errors surfaced to handlers.
 +var (
 +	ErrSameBranch       = errors.New("pulls: base and head must differ")
 +	ErrBaseNotFound     = errors.New("pulls: base ref not found")
 +	ErrHeadNotFound     = errors.New("pulls: head ref not found")
 +	ErrNoCommitsToMerge = errors.New("pulls: head has no commits ahead of base")
 +	ErrAlreadyMerged    = errors.New("pulls: already merged")
 +	ErrAlreadyClosed    = errors.New("pulls: already closed")
 +	ErrMergeBlocked     = errors.New("pulls: merge blocked (mergeable_state != clean)")
 +	ErrMergeMethodOff   = errors.New("pulls: requested merge method is disabled on this repo")
 +	ErrConcurrentMerge  = errors.New("pulls: PR is being merged by another request")
 +	ErrPRNotFound       = errors.New("pulls: PR not found")
 +)
++
 +// CreateParams describes a new-PR request.
 +type CreateParams struct {
 +	RepoID       int64
 +	AuthorUserID int64
 +	Title        string
 +	Body         string
 +	BaseRef      string
 +	HeadRef      string
 +	Draft        bool
 +	GitDir       string // resolved from RepoFS by the caller
 +}
++
 +// CreateResult bundles the issue row + the PR row (post-snapshot).
 +type CreateResult struct {
 +	Issue       issuesdb.Issue
 +	PullRequest pullsdb.PullRequest
 +}
++
 +// Create opens a PR. Validates that base/head are distinct and resolve
 +// in the on-disk repo, snapshots their OIDs, then creates the issues
 +// row + pull_requests row in one tx. Mergeability is `unknown` until
 +// the worker job ticks.
 +func Create(ctx context.Context, deps Deps, p CreateParams) (CreateResult, error) {
 +	base := strings.TrimSpace(p.BaseRef)
 +	head := strings.TrimSpace(p.HeadRef)
 +	if base == "" || head == "" || base == head {
 +		return CreateResult{}, ErrSameBranch
 +	}
 +	baseOID, err := repogit.ResolveRefOID(ctx, p.GitDir, base)
 +	if err != nil {
 +		if errors.Is(err, repogit.ErrRefNotFound) {
 +			return CreateResult{}, ErrBaseNotFound
 +		}
 +		return CreateResult{}, fmt.Errorf("resolve base: %w", err)
 +	}
 +	headOID, err := repogit.ResolveRefOID(ctx, p.GitDir, head)
 +	if err != nil {
 +		if errors.Is(err, repogit.ErrRefNotFound) {
 +			return CreateResult{}, ErrHeadNotFound
 +		}
 +		return CreateResult{}, fmt.Errorf("resolve head: %w", err)
 +	}
 +	if baseOID == headOID {
 +		return CreateResult{}, ErrNoCommitsToMerge
 +	}
++
 +	// Open the issues row first via the issues orchestrator so we get
 +	// the per-repo number allocation, body markdown render, and
 +	// reference indexing for free.
 +	issueRow, err := issues.Create(ctx, issues.Deps{Pool: deps.Pool, Logger: deps.Logger}, issues.CreateParams{
 +		RepoID:       p.RepoID,
 +		AuthorUserID: p.AuthorUserID,
 +		Title:        p.Title,
 +		Body:         p.Body,
 +		Kind:         "pr",
 +	})
 +	if err != nil {
 +		return CreateResult{}, err
 +	}
++
 +	prRow, err := pullsdb.New().CreatePullRequest(ctx, deps.Pool, pullsdb.CreatePullRequestParams{
 +		IssueID:     issueRow.ID,
 +		BaseRef:     base,
 +		HeadRef:     head,
 +		HeadRepoID:  p.RepoID,
 +		BaseOid:     baseOID,
 +		HeadOid:     headOID,
 +		Draft:       p.Draft,
 +	})
 +	if err != nil {
 +		return CreateResult{}, fmt.Errorf("create pull_request: %w", err)
 +	}
++
 +	// Best-effort initial synchronize so the PR view has commits + files
 +	// even before the worker queue runs. Failures here don't fail the
 +	// open — the worker will retry on the next tick.
 +	if err := refreshCommitsAndFiles(ctx, deps, p.GitDir, prRow.IssueID, baseOID, headOID); err != nil {
 +		if deps.Logger != nil {
 +			deps.Logger.WarnContext(ctx, "pulls: initial sync", "error", err, "pr_id", prRow.IssueID)
 +		}
 +	}
++
 +	return CreateResult{Issue: issueRow, PullRequest: prRow}, nil
 +}
++
 +// refreshCommitsAndFiles is shared by Create + Synchronize. Truncates +
 +// re-fills `pull_request_commits` and `pull_request_files`.
 +func refreshCommitsAndFiles(ctx context.Context, deps Deps, gitDir string, prID int64, baseOID, headOID string) error {
 +	commits, err := repogit.CommitsBetweenDetail(ctx, gitDir, baseOID, headOID, 250)
 +	if err != nil {
 +		return fmt.Errorf("commits: %w", err)
 +	}
 +	files, err := repogit.FilesChangedBetween(ctx, gitDir, baseOID, headOID)
 +	if err != nil {
 +		return fmt.Errorf("files: %w", err)
 +	}
 +	tx, err := deps.Pool.Begin(ctx)
 +	if err != nil {
 +		return err
 +	}
 +	committed := false
 +	defer func() {
 +		if !committed {
 +			_ = tx.Rollback(ctx)
 +		}
 +	}()
 +	q := pullsdb.New()
 +	if err := q.ClearPullRequestCommits(ctx, tx, prID); err != nil {
 +		return err
 +	}
 +	if err := q.ClearPullRequestFiles(ctx, tx, prID); err != nil {
 +		return err
 +	}
 +	for i, c := range commits {
 +		var ats, cts pgtype.Timestamptz
 +		if !c.AuthorWhen.IsZero() {
 +			ats = pgtype.Timestamptz{Time: c.AuthorWhen, Valid: true}
 +		}
 +		if !c.CommitterWhen.IsZero() {
 +			cts = pgtype.Timestamptz{Time: c.CommitterWhen, Valid: true}
 +		}
 +		if err := q.InsertPullRequestCommit(ctx, tx, pullsdb.InsertPullRequestCommitParams{
 +			PrID:           prID,
 +			Sha:            c.OID,
 +			Position:       int32(i),
 +			AuthorName:     c.AuthorName,
 +			AuthorEmail:    c.AuthorEmail,
 +			CommitterName:  c.CommitterName,
 +			CommitterEmail: c.CommitterEmail,
 +			Subject:        c.Subject,
 +			Body:           c.Body,
 +			AuthoredAt:     ats,
 +			CommittedAt:    cts,
 +		}); err != nil {
 +			return err
 +		}
 +	}
 +	for _, f := range files {
 +		oldPath := pgtype.Text{}
 +		if f.OldPath != "" {
 +			oldPath = pgtype.Text{String: f.OldPath, Valid: true}
 +		}
 +		if err := q.InsertPullRequestFile(ctx, tx, pullsdb.InsertPullRequestFileParams{
 +			PrID:      prID,
 +			Path:      f.Path,
 +			Status:    pullsdb.PrFileStatus(f.Status),
 +			OldPath:   oldPath,
 +			Additions: int32(f.Additions),
 +			Deletions: int32(f.Deletions),
 +			Changes:   int32(f.Additions + f.Deletions),
 +		}); err != nil {
 +			return err
 +		}
 +	}
 +	if err := q.SetPullRequestSnapshot(ctx, tx, pullsdb.SetPullRequestSnapshotParams{
 +		IssueID: prID, BaseOid: baseOID, HeadOid: headOID,
 +	}); err != nil {
 +		return err
 +	}
 +	if err := tx.Commit(ctx); err != nil {
 +		return err
 +	}
 +	committed = true
 +	return nil
 +}
++
 +// Synchronize re-snapshots the PR's base/head OIDs, refreshes the
 +// commits + files lists, and emits a `synchronized` event into the
 +// issue timeline. Called from the pr:synchronize worker job after
 +// any push to the head ref.
 +func Synchronize(ctx context.Context, deps Deps, gitDir string, prID int64) error {
 +	q := pullsdb.New()
 +	pr, err := q.GetPullRequestByIssueID(ctx, deps.Pool, prID)
 +	if err != nil {
 +		if errors.Is(err, pgx.ErrNoRows) {
 +			return ErrPRNotFound
 +		}
 +		return err
 +	}
 +	baseOID, err := repogit.ResolveRefOID(ctx, gitDir, pr.BaseRef)
 +	if err != nil {
 +		return fmt.Errorf("resolve base: %w", err)
 +	}
 +	headOID, err := repogit.ResolveRefOID(ctx, gitDir, pr.HeadRef)
 +	if err != nil {
 +		return fmt.Errorf("resolve head: %w", err)
 +	}
 +	if err := refreshCommitsAndFiles(ctx, deps, gitDir, prID, baseOID, headOID); err != nil {
 +		return err
 +	}
 +	// Reset mergeability to unknown so the next mergeability tick
 +	// recomputes against the fresh snapshot.
 +	if err := q.SetPullRequestMergeability(ctx, deps.Pool, pullsdb.SetPullRequestMergeabilityParams{
 +		IssueID:        prID,
 +		Mergeable:      pgtype.Bool{},
 +		MergeableState: pullsdb.PrMergeableStateUnknown,
 +	}); err != nil {
 +		return fmt.Errorf("reset mergeability: %w", err)
 +	}
 +	// Emit the synchronized timeline event.
 +	iq := issuesdb.New()
 +	if _, err := iq.InsertIssueEvent(ctx, deps.Pool, issuesdb.InsertIssueEventParams{
 +		IssueID: prID,
 +		Kind:    "synchronized",
 +		Meta:    []byte(fmt.Sprintf(`{"head_oid":%q}`, headOID)),
 +	}); err != nil {
 +		return fmt.Errorf("emit event: %w", err)
 +	}
 +	return nil
 +}
++
 +// Mergeability runs the merge-tree probe and persists the result.
 +func Mergeability(ctx context.Context, deps Deps, gitDir string, prID int64) error {
 +	q := pullsdb.New()
 +	pr, err := q.GetPullRequestByIssueID(ctx, deps.Pool, prID)
 +	if err != nil {
 +		return err
 +	}
 +	if pr.BaseOid == "" || pr.HeadOid == "" {
 +		return nil // synchronize hasn't run yet; nothing to probe
 +	}
 +	// Behind: head has no commits ahead of base.
 +	gitDirCtx := ctx
 +	commits, err := repogit.CommitsBetweenDetail(gitDirCtx, gitDir, pr.BaseOid, pr.HeadOid, 1)
 +	if err != nil && !errors.Is(err, repogit.ErrRefNotFound) {
 +		return err
 +	}
 +	if len(commits) == 0 {
 +		return q.SetPullRequestMergeability(ctx, deps.Pool, pullsdb.SetPullRequestMergeabilityParams{
 +			IssueID:        prID,
 +			Mergeable:      pgtype.Bool{Bool: false, Valid: true},
 +			MergeableState: pullsdb.PrMergeableStateBehind,
 +		})
 +	}
 +	res, err := repogit.ProbeMerge(gitDirCtx, gitDir, pr.BaseOid, pr.HeadOid)
 +	if err != nil {
 +		return fmt.Errorf("probe: %w", err)
 +	}
 +	state := pullsdb.PrMergeableStateClean
 +	mergeable := true
 +	if res.HasConflict {
 +		state = pullsdb.PrMergeableStateDirty
 +		mergeable = false
 +	}
 +	return q.SetPullRequestMergeability(ctx, deps.Pool, pullsdb.SetPullRequestMergeabilityParams{
 +		IssueID:        prID,
 +		Mergeable:      pgtype.Bool{Bool: mergeable, Valid: true},
 +		MergeableState: state,
 +	})
 +}
++
 +// EditPR updates the PR's title + body. Body markdown is re-rendered
 +// via the same pipeline issues.Create uses so HTML is consistent.
 +func EditPR(ctx context.Context, deps Deps, prID int64, title, body string) error {
 +	title = strings.TrimSpace(title)
 +	if title == "" {
 +		return issues.ErrEmptyTitle
 +	}
 +	if len(title) > 256 {
 +		return issues.ErrTitleTooLong
 +	}
 +	if len(body) > 65535 {
 +		return issues.ErrBodyTooLong
 +	}
 +	html, _ := mdrender.RenderHTML([]byte(body))
 +	q := issuesdb.New()
 +	return q.UpdateIssueTitleBody(ctx, deps.Pool, issuesdb.UpdateIssueTitleBodyParams{
 +		ID:             prID,
 +		Title:          title,
 +		Body:           body,
 +		BodyHtmlCached: pgtype.Text{String: html, Valid: html != ""},
 +	})
 +}
++
 +// SetReady flips draft → false and emits a `ready_for_review` event.
 +func SetReady(ctx context.Context, deps Deps, actorUserID, prID int64) error {
 +	q := pullsdb.New()
 +	tx, err := deps.Pool.Begin(ctx)
 +	if err != nil {
 +		return err
 +	}
 +	committed := false
 +	defer func() {
 +		if !committed {
 +			_ = tx.Rollback(ctx)
 +		}
 +	}()
 +	if err := q.SetPullRequestDraft(ctx, tx, pullsdb.SetPullRequestDraftParams{IssueID: prID, Draft: false}); err != nil {
 +		return err
 +	}
 +	iq := issuesdb.New()
 +	if _, err := iq.InsertIssueEvent(ctx, tx, issuesdb.InsertIssueEventParams{
 +		IssueID:     prID,
 +		ActorUserID: pgtype.Int8{Int64: actorUserID, Valid: actorUserID != 0},
 +		Kind:        "ready_for_review",
 +		Meta:        []byte("{}"),
 +	}); err != nil {
 +		return err
 +	}
 +	if err := tx.Commit(ctx); err != nil {
 +		return err
 +	}
 +	committed = true
 +	return nil
 +}
++
 +// AllowedMethod returns true when the repo allows the named merge
 +// strategy. Falls open for unknown methods so callers get a clear
 +// error from the orchestrator.
 +func AllowedMethod(repo reposdb.Repo, method string) bool {
 +	switch method {
 +	case "merge":
 +		return repo.AllowMergeCommit
 +	case "squash":
 +		return repo.AllowSquashMerge
 +	case "rebase":
 +		return repo.AllowRebaseMerge
 +	}
 +	return false
 +}

internal/pulls/pulls_test.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package pulls_test
++
 +import (
 +	"context"
 +	"io"
 +	"log/slog"
 +	"os"
 +	"os/exec"
 +	"path/filepath"
 +	"strings"
 +	"sync"
 +	"testing"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +	"github.com/jackc/pgx/v5/pgxpool"
++
 +	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"
 +	"github.com/tenseleyFlow/shithub/internal/pulls"
 +	pullsdb "github.com/tenseleyFlow/shithub/internal/pulls/sqlc"
 +	reposdb "github.com/tenseleyFlow/shithub/internal/repos/sqlc"
 +	"github.com/tenseleyFlow/shithub/internal/testing/dbtest"
 +	usersdb "github.com/tenseleyFlow/shithub/internal/users/sqlc"
 +)
++
 +const fixtureHash = "$argon2id$v=19$m=16384,t=1,p=1$" +
 +	"AAAAAAAAAAAAAAAA$" +
 +	"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
++
 +// gitCmd suppresses the gosec G204 noise — every invocation runs
 +// against a t.TempDir path the test set up.
 +func gitCmd(args ...string) *exec.Cmd {
 +	//nolint:gosec
 +	return exec.Command("git", args...)
 +}
++
 +// fixture spins a real bare git repo on disk + a DB row pair (user
 +// + repo + ensured issue counter) so the orchestrator's path-on-disk
 +// assumptions hold.
 +type fixture struct {
 +	pool   *pgxpool.Pool
 +	deps   pulls.Deps
 +	userID int64
 +	repoID int64
 +	gitDir string
 +}
++
 +func setup(t *testing.T) fixture {
 +	t.Helper()
 +	pool := dbtest.NewTestDB(t)
 +	ctx := context.Background()
++
 +	uq := usersdb.New()
 +	user, err := uq.CreateUser(ctx, pool, usersdb.CreateUserParams{
 +		Username: "alice", DisplayName: "Alice", PasswordHash: fixtureHash,
 +	})
 +	if err != nil {
 +		t.Fatalf("CreateUser: %v", err)
 +	}
 +	em, err := uq.CreateUserEmail(ctx, pool, usersdb.CreateUserEmailParams{
 +		UserID: user.ID, Email: "alice@example.com", IsPrimary: true, Verified: true,
 +	})
 +	if err != nil {
 +		t.Fatalf("CreateUserEmail: %v", err)
 +	}
 +	if err := uq.LinkUserPrimaryEmail(ctx, pool, usersdb.LinkUserPrimaryEmailParams{
 +		ID: user.ID, PrimaryEmailID: pgtype.Int8{Int64: em.ID, Valid: true},
 +	}); err != nil {
 +		t.Fatalf("LinkUserPrimaryEmail: %v", err)
 +	}
++
 +	rq := reposdb.New()
 +	repo, err := rq.CreateRepo(ctx, pool, reposdb.CreateRepoParams{
 +		OwnerUserID:   pgtype.Int8{Int64: user.ID, Valid: true},
 +		Name:          "demo",
 +		DefaultBranch: "trunk",
 +		Visibility:    reposdb.RepoVisibilityPublic,
 +	})
 +	if err != nil {
 +		t.Fatalf("CreateRepo: %v", err)
 +	}
++
 +	iq := issuesdb.New()
 +	if err := iq.EnsureRepoIssueCounter(ctx, pool, repo.ID); err != nil {
 +		t.Fatalf("EnsureRepoIssueCounter: %v", err)
 +	}
++
 +	root := t.TempDir()
 +	gitDir := filepath.Join(root, "demo.git")
 +	if out, err := gitCmd("init", "--bare", "-b", "trunk", gitDir).CombinedOutput(); err != nil {
 +		t.Fatalf("git init --bare: %v (%s)", err, out)
 +	}
++
 +	w := io.Discard
 +	if testing.Verbose() {
 +		w = os.Stderr
 +	}
 +	deps := pulls.Deps{
 +		Pool:   pool,
 +		Logger: slog.New(slog.NewTextHandler(w, nil)),
 +	}
 +	return fixture{pool: pool, deps: deps, userID: user.ID, repoID: repo.ID, gitDir: gitDir}
 +}
++
 +// commitOnBranch creates a commit on branch from a temp worktree.
 +// Returns the new HEAD oid.
 +func commitOnBranch(t *testing.T, gitDir, branch, msg, file, contents string) string {
 +	t.Helper()
 +	wt := t.TempDir()
 +	// Add a worktree that creates the branch if missing.
 +	addArgs := []string{"-C", gitDir, "worktree", "add"}
 +	// If branch doesn't exist yet, create it; otherwise check it out.
 +	if _, err := gitCmd("-C", gitDir, "show-ref", "--verify", "refs/heads/"+branch).CombinedOutput(); err != nil {
 +		addArgs = append(addArgs, "-b", branch, wt)
 +	} else {
 +		addArgs = append(addArgs, wt, branch)
 +	}
 +	if out, err := gitCmd(addArgs...).CombinedOutput(); err != nil {
 +		t.Fatalf("worktree add %s: %v (%s)", branch, err, out)
 +	}
 +	defer func() {
 +		_ = gitCmd("-C", gitDir, "worktree", "remove", "--force", wt).Run()
 +	}()
++
 +	if err := os.WriteFile(filepath.Join(wt, file), []byte(contents), 0o644); err != nil { //nolint:gosec
 +		t.Fatalf("write %s: %v", file, err)
 +	}
 +	for _, args := range [][]string{
 +		{"-C", wt, "config", "user.name", "Alice"},
 +		{"-C", wt, "config", "user.email", "alice@example.com"},
 +		{"-C", wt, "add", "."},
 +		{"-C", wt, "commit", "-m", msg},
 +	} {
 +		if out, err := gitCmd(args...).CombinedOutput(); err != nil {
 +			t.Fatalf("%v: %v (%s)", args, err, out)
 +		}
 +	}
 +	out, err := gitCmd("-C", wt, "rev-parse", "HEAD").Output()
 +	if err != nil {
 +		t.Fatalf("rev-parse HEAD: %v", err)
 +	}
 +	return strings.TrimSpace(string(out))
 +}
++
 +func TestCreate_OpensPRWithIssueRow(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	commitOnBranch(t, f.gitDir, "feature", "add foo", "foo.txt", "foo\n")
++
 +	res, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID:       f.repoID,
 +		AuthorUserID: f.userID,
 +		Title:        "Add foo",
 +		Body:         "fixes nothing yet",
 +		BaseRef:      "trunk",
 +		HeadRef:      "feature",
 +		GitDir:       f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create: %v", err)
 +	}
 +	if res.Issue.Kind != issuesdb.IssueKindPr {
 +		t.Errorf("issue kind: got %s, want pr", res.Issue.Kind)
 +	}
 +	if res.PullRequest.BaseRef != "trunk" || res.PullRequest.HeadRef != "feature" {
 +		t.Errorf("ref mismatch: %+v", res.PullRequest)
 +	}
 +	if res.PullRequest.BaseOid == "" || res.PullRequest.HeadOid == "" {
 +		t.Errorf("OIDs not snapshotted: %+v", res.PullRequest)
 +	}
 +	commits, _ := pullsdb.New().ListPullRequestCommits(context.Background(), f.pool, res.PullRequest.IssueID)
 +	if len(commits) == 0 {
 +		t.Errorf("expected commits populated by initial sync")
 +	}
 +}
++
 +func TestCreate_RejectsSameBranch(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	_, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "x", BaseRef: "trunk", HeadRef: "trunk", GitDir: f.gitDir,
 +	})
 +	if err == nil {
 +		t.Fatalf("expected ErrSameBranch, got nil")
 +	}
 +}
++
 +func TestMergeability_Clean(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	commitOnBranch(t, f.gitDir, "feature", "add foo", "foo.txt", "foo\n")
 +	res, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "x", BaseRef: "trunk", HeadRef: "feature", GitDir: f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create: %v", err)
 +	}
 +	if err := pulls.Mergeability(context.Background(), f.deps, f.gitDir, res.PullRequest.IssueID); err != nil {
 +		t.Fatalf("Mergeability: %v", err)
 +	}
 +	pr, _ := pullsdb.New().GetPullRequestByIssueID(context.Background(), f.pool, res.PullRequest.IssueID)
 +	if pr.MergeableState != pullsdb.PrMergeableStateClean {
 +		t.Errorf("got %s, want clean", pr.MergeableState)
 +	}
 +}
++
 +func TestMergeability_Dirty(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "shared.txt", "base content\n")
 +	// Modify shared.txt on trunk.
 +	commitOnBranch(t, f.gitDir, "trunk", "trunk edit", "shared.txt", "trunk content\n")
 +	// Branch from earlier trunk and also edit shared.txt → conflict.
 +	// Create the feature branch from the first trunk commit.
 +	out, err := gitCmd("-C", f.gitDir, "rev-list", "--reverse", "trunk").Output()
 +	if err != nil {
 +		t.Fatalf("rev-list: %v", err)
 +	}
 +	firstSHA := strings.SplitN(strings.TrimSpace(string(out)), "\n", 2)[0]
 +	if out, err := gitCmd("-C", f.gitDir, "branch", "feature", firstSHA).CombinedOutput(); err != nil {
 +		t.Fatalf("create feature branch: %v (%s)", err, out)
 +	}
 +	commitOnBranch(t, f.gitDir, "feature", "feature edit", "shared.txt", "feature content\n")
++
 +	res, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "x", BaseRef: "trunk", HeadRef: "feature", GitDir: f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create: %v", err)
 +	}
 +	if err := pulls.Mergeability(context.Background(), f.deps, f.gitDir, res.PullRequest.IssueID); err != nil {
 +		t.Fatalf("Mergeability: %v", err)
 +	}
 +	pr, _ := pullsdb.New().GetPullRequestByIssueID(context.Background(), f.pool, res.PullRequest.IssueID)
 +	if pr.MergeableState != pullsdb.PrMergeableStateDirty {
 +		t.Errorf("got %s, want dirty", pr.MergeableState)
 +	}
 +}
++
 +func TestMerge_MergeCommit(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	commitOnBranch(t, f.gitDir, "feature", "add foo", "foo.txt", "foo\n")
 +	res, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "Add foo", BaseRef: "trunk", HeadRef: "feature", GitDir: f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create: %v", err)
 +	}
 +	if err := pulls.Mergeability(context.Background(), f.deps, f.gitDir, res.PullRequest.IssueID); err != nil {
 +		t.Fatalf("Mergeability: %v", err)
 +	}
 +	if err := pulls.Merge(context.Background(), f.deps, pulls.MergeParams{
 +		PRID: res.PullRequest.IssueID, ActorUserID: f.userID,
 +		GitDir: f.gitDir, Method: "merge",
 +	}); err != nil {
 +		t.Fatalf("Merge: %v", err)
 +	}
 +	pr, _ := pullsdb.New().GetPullRequestByIssueID(context.Background(), f.pool, res.PullRequest.IssueID)
 +	if !pr.MergedAt.Valid {
 +		t.Errorf("merged_at not set")
 +	}
 +	if !pr.MergeCommitSha.Valid {
 +		t.Errorf("merge_commit_sha not set")
 +	}
 +	// Issue side closed?
 +	iq := issuesdb.New()
 +	issue, _ := iq.GetIssueByID(context.Background(), f.pool, res.PullRequest.IssueID)
 +	if issue.State != issuesdb.IssueStateClosed {
 +		t.Errorf("issue state: got %s, want closed", issue.State)
 +	}
 +}
++
 +func TestMerge_RejectsConcurrentDouble(t *testing.T) {
 +	f := setup(t)
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	commitOnBranch(t, f.gitDir, "feature", "add foo", "foo.txt", "foo\n")
 +	res, err := pulls.Create(context.Background(), f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "x", BaseRef: "trunk", HeadRef: "feature", GitDir: f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create: %v", err)
 +	}
 +	_ = pulls.Mergeability(context.Background(), f.deps, f.gitDir, res.PullRequest.IssueID)
++
 +	var wg sync.WaitGroup
 +	errs := make([]error, 2)
 +	for i := 0; i < 2; i++ {
 +		wg.Add(1)
 +		go func(i int) {
 +			defer wg.Done()
 +			errs[i] = pulls.Merge(context.Background(), f.deps, pulls.MergeParams{
 +				PRID: res.PullRequest.IssueID, ActorUserID: f.userID,
 +				GitDir: f.gitDir, Method: "merge",
 +			})
 +		}(i)
 +	}
 +	wg.Wait()
++
 +	successes := 0
 +	for _, e := range errs {
 +		if e == nil {
 +			successes++
 +		}
 +	}
 +	if successes != 1 {
 +		t.Errorf("expected exactly one successful merge, got %d (errors: %v, %v)", successes, errs[0], errs[1])
 +	}
 +}
++
 +func TestMerge_LinkedIssueAutoClose(t *testing.T) {
 +	f := setup(t)
 +	ctx := context.Background()
++
 +	// Create an issue first so the PR body can reference it.
 +	iq := issuesdb.New()
 +	num, err := iq.AllocateIssueNumber(ctx, f.pool, f.repoID)
 +	if err != nil {
 +		t.Fatalf("AllocateIssueNumber: %v", err)
 +	}
 +	issue, err := iq.CreateIssue(ctx, f.pool, issuesdb.CreateIssueParams{
 +		RepoID:       f.repoID,
 +		Number:       num,
 +		Kind:         issuesdb.IssueKindIssue,
 +		Title:        "bug",
 +		Body:         "fix me",
 +		AuthorUserID: pgtype.Int8{Int64: f.userID, Valid: true},
 +	})
 +	if err != nil {
 +		t.Fatalf("CreateIssue: %v", err)
 +	}
++
 +	commitOnBranch(t, f.gitDir, "trunk", "init", "README.md", "hi\n")
 +	commitOnBranch(t, f.gitDir, "feature", "add foo", "foo.txt", "foo\n")
++
 +	res, err := pulls.Create(ctx, f.deps, pulls.CreateParams{
 +		RepoID: f.repoID, AuthorUserID: f.userID,
 +		Title: "fix the bug", Body: "Fixes #1",
 +		BaseRef: "trunk", HeadRef: "feature", GitDir: f.gitDir,
 +	})
 +	if err != nil {
 +		t.Fatalf("Create PR: %v", err)
 +	}
 +	_ = pulls.Mergeability(ctx, f.deps, f.gitDir, res.PullRequest.IssueID)
++
 +	if err := pulls.Merge(ctx, f.deps, pulls.MergeParams{
 +		PRID: res.PullRequest.IssueID, ActorUserID: f.userID,
 +		GitDir: f.gitDir, Method: "squash",
 +	}); err != nil {
 +		t.Fatalf("Merge: %v", err)
 +	}
++
 +	// The pre-existing issue (#1) should now be closed.
 +	got, err := iq.GetIssueByID(ctx, f.pool, issue.ID)
 +	if err != nil {
 +		t.Fatalf("GetIssueByID: %v", err)
 +	}
 +	if got.State != issuesdb.IssueStateClosed {
 +		t.Errorf("linked issue state: got %s, want closed", got.State)
 +	}
 +}

internal/pulls/state.goadded

 +// SPDX-License-Identifier: AGPL-3.0-or-later
++
 +package pulls
++
 +import (
 +	"context"
 +	"errors"
++
 +	"github.com/tenseleyFlow/shithub/internal/issues"
 +	pullsdb "github.com/tenseleyFlow/shithub/internal/pulls/sqlc"
 +	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"
 +)
++
 +// SetState delegates to issues.SetState with a couple of PR-specific
 +// guardrails:
 +//
 +//   - reopening a merged PR is a no-op (a merged PR can't reopen).
 +//   - reopening when base or head no longer resolves returns a typed
 +//     error so the handler can render "branches moved, cannot reopen".
 +func SetState(ctx context.Context, deps Deps, gitDir string, actorUserID, prID int64, newState string) error {
 +	q := pullsdb.New()
 +	pr, err := q.GetPullRequestByIssueID(ctx, deps.Pool, prID)
 +	if err != nil {
 +		return ErrPRNotFound
 +	}
 +	if pr.MergedAt.Valid {
 +		return ErrAlreadyMerged
 +	}
 +	if newState == "open" {
 +		// Validate refs still resolve; otherwise reopen would leave a PR
 +		// pointing at a missing branch which the diff renderer can't
 +		// handle cleanly.
 +		if _, err := repogit.ResolveRefOID(ctx, gitDir, pr.BaseRef); err != nil {
 +			if errors.Is(err, repogit.ErrRefNotFound) {
 +				return ErrBaseNotFound
 +			}
 +			return err
 +		}
 +		if _, err := repogit.ResolveRefOID(ctx, gitDir, pr.HeadRef); err != nil {
 +			if errors.Is(err, repogit.ErrRefNotFound) {
 +				return ErrHeadNotFound
 +			}
 +			return err
 +		}
 +	}
 +	return issues.SetState(ctx, issues.Deps{Pool: deps.Pool, Logger: deps.Logger}, actorUserID, prID, newState, "")
 +}