add transition operations to the gerrit client

SubmitChange, AbandonChange, RestoreChange, SetWorkInProgress, and
SetReadyForReview cover the five change-state transitions, each behind
the same write gate as reviews. go-gerrit exposes no /wip endpoint, so
SetWorkInProgress rides a review via ReviewInput.work_in_progress --
same wire effect.

Gerrit refusals (blocked submit, restore of a merged change) reach the
caller verbatim through the recovered error body.

Refs: #18

Author: xobotyi

internal/gerritclient/transition.go

@@ -0,0 +1,112 @@
+package gerritclient
+
+import (
+	"context"
+
+	"dev.gaijin.team/go/golib/e"
+	"dev.gaijin.team/go/golib/fields"
+	gerrit "github.com/andygrunwald/go-gerrit"
+)
+
+// Sentinels for change-state transitions.
+var (
+	ErrSubmitChange  = e.New("submit change")
+	ErrAbandonChange = e.New("abandon change")
+	ErrRestoreChange = e.New("restore change")
+	ErrSetWIP        = e.New("set work in progress")
+	ErrSetReady      = e.New("set ready for review")
+)
+
+// SubmitChange submits a change (NEW -> MERGED). Gerrit refuses submits that
+// fail submit requirements; the refusal reason is carried in the wrapped
+// error. Trail-leaving — gated by project scoping and the own-changes
+// restriction.
+func (c *Client) SubmitChange(ctx context.Context, changeID string) (*gerrit.ChangeInfo, error) {
+	if err := c.checkWriteScope(ctx, changeID); err != nil {
+		return nil, ErrSubmitChange.Wrap(err)
+	}
+
+	info, resp, err := c.gerrit.Changes.SubmitChange(ctx, changeID, &gerrit.SubmitInput{})
+	if err != nil {
+		return nil, ErrSubmitChange.Wrap(apiError(resp, err), fields.F("change", changeID))
+	}
+
+	if info == nil {
+		return nil, ErrSubmitChange.Wrap(errEmptyResponse, fields.F("change", changeID))
+	}
+
+	return info, nil
+}
+
+// AbandonChange abandons a change (NEW -> ABANDONED) with an optional
+// message. Trail-leaving — gated by project scoping and the own-changes
+// restriction.
+func (c *Client) AbandonChange(ctx context.Context, changeID, message string) (*gerrit.ChangeInfo, error) {
+	if err := c.checkWriteScope(ctx, changeID); err != nil {
+		return nil, ErrAbandonChange.Wrap(err)
+	}
+
+	info, resp, err := c.gerrit.Changes.AbandonChange(ctx, changeID, &gerrit.AbandonInput{Message: message})
+	if err != nil {
+		return nil, ErrAbandonChange.Wrap(apiError(resp, err), fields.F("change", changeID))
+	}
+
+	if info == nil {
+		return nil, ErrAbandonChange.Wrap(errEmptyResponse, fields.F("change", changeID))
+	}
+
+	return info, nil
+}
+
+// RestoreChange restores an abandoned change (ABANDONED -> NEW) with an
+// optional message. Trail-leaving — gated by project scoping and the
+// own-changes restriction.
+func (c *Client) RestoreChange(ctx context.Context, changeID, message string) (*gerrit.ChangeInfo, error) {
+	if err := c.checkWriteScope(ctx, changeID); err != nil {
+		return nil, ErrRestoreChange.Wrap(err)
+	}
+
+	info, resp, err := c.gerrit.Changes.RestoreChange(ctx, changeID, &gerrit.RestoreInput{Message: message})
+	if err != nil {
+		return nil, ErrRestoreChange.Wrap(apiError(resp, err), fields.F("change", changeID))
+	}
+
+	if info == nil {
+		return nil, ErrRestoreChange.Wrap(errEmptyResponse, fields.F("change", changeID))
+	}
+
+	return info, nil
+}
+
+// SetWorkInProgress marks a change as work-in-progress with an optional
+// message. go-gerrit exposes no /wip endpoint, so the toggle rides a review
+// via ReviewInput.work_in_progress — same wire effect. Trail-leaving — gated
+// by project scoping and the own-changes restriction (via SetReview).
+func (c *Client) SetWorkInProgress(ctx context.Context, changeID, message string) error {
+	input := &gerrit.ReviewInput{
+		Message:        message,
+		WorkInProgress: true,
+	}
+
+	if _, err := c.SetReview(ctx, changeID, "", input); err != nil {
+		return ErrSetWIP.Wrap(err)
+	}
+
+	return nil
+}
+
+// SetReadyForReview marks a work-in-progress change as ready for review with
+// an optional message. Trail-leaving — gated by project scoping and the
+// own-changes restriction.
+func (c *Client) SetReadyForReview(ctx context.Context, changeID, message string) error {
+	if err := c.checkWriteScope(ctx, changeID); err != nil {
+		return ErrSetReady.Wrap(err)
+	}
+
+	resp, err := c.gerrit.Changes.SetReadyForReview(ctx, changeID, &gerrit.ReadyForReviewInput{Message: message})
+	if err != nil {
+		return ErrSetReady.Wrap(apiError(resp, err), fields.F("change", changeID))
+	}
+
+	return nil
+}

internal/gerritclient/transition_test.go

@@ -0,0 +1,153 @@
+package gerritclient_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/gerritclient"
+)
+
+// transitionCalls maps every transition operation to a uniform closure so the
+// endpoint and gating tables below can iterate over them.
+func transitionCalls() []struct {
+	name     string
+	call     func(t *testing.T, c *gerritclient.Client) error
+	wantPath string
+} {
+	return []struct {
+		name     string
+		call     func(t *testing.T, c *gerritclient.Client) error
+		wantPath string
+	}{
+		{
+			name: "submit",
+			call: func(t *testing.T, c *gerritclient.Client) error {
+				t.Helper()
+
+				_, err := c.SubmitChange(t.Context(), "123")
+
+				return err
+			},
+			wantPath: "/a/changes/123/submit",
+		},
+		{
+			name: "abandon",
+			call: func(t *testing.T, c *gerritclient.Client) error {
+				t.Helper()
+
+				_, err := c.AbandonChange(t.Context(), "123", "stale")
+
+				return err
+			},
+			wantPath: "/a/changes/123/abandon",
+		},
+		{
+			name: "restore",
+			call: func(t *testing.T, c *gerritclient.Client) error {
+				t.Helper()
+
+				_, err := c.RestoreChange(t.Context(), "123", "back")
+
+				return err
+			},
+			wantPath: "/a/changes/123/restore",
+		},
+		{
+			name: "wip",
+			call: func(t *testing.T, c *gerritclient.Client) error {
+				t.Helper()
+
+				return c.SetWorkInProgress(t.Context(), "123", "parking")
+			},
+			wantPath: "/a/changes/123/revisions/current/review",
+		},
+		{
+			name: "ready",
+			call: func(t *testing.T, c *gerritclient.Client) error {
+				t.Helper()
+
+				return c.SetReadyForReview(t.Context(), "123", "ptal")
+			},
+			wantPath: "/a/changes/123/ready",
+		},
+	}
+}
+
+func Test_Transitions_Endpoints(t *testing.T) {
+	t.Parallel()
+
+	for _, tt := range transitionCalls() {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			client, posts := reviewClient(t, testConfig(""), 42)
+
+			require.NoError(t, tt.call(t, client))
+
+			require.Len(t, *posts, 1)
+			assert.Equal(t, tt.wantPath, (*posts)[0])
+		})
+	}
+}
+
+func Test_Transitions_Gating(t *testing.T) {
+	t.Parallel()
+
+	for _, tt := range transitionCalls() {
+		t.Run(tt.name+" refused on foreign change", func(t *testing.T) {
+			t.Parallel()
+
+			client, posts := reviewClient(t, testConfig(""), 7)
+
+			err := tt.call(t, client)
+
+			require.Error(t, err)
+			require.ErrorIs(t, err, gerritclient.ErrOwnChangesOnly)
+			assert.Empty(t, *posts, "no mutating request may leave the process")
+		})
+	}
+}
+
+// Test_Transitions_ConflictSurfaced pins that a Gerrit refusal (409 with the
+// reason in the body) reaches the caller verbatim — the agent must see why a
+// submit was blocked.
+func Test_Transitions_ConflictSurfaced(t *testing.T) {
+	t.Parallel()
+
+	changeJSON := ")]}'\n" + `{"_number":123,"project":"core","branch":"main",` +
+		`"owner":{"_account_id":42,"username":"bot"}}`
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.URL.Path == "/a/accounts/self":
+			_, _ = w.Write([]byte(scopedSelfJSON))
+
+		case r.Method == http.MethodPost:
+			w.WriteHeader(http.StatusConflict)
+
+			_, _ = w.Write([]byte("Failed to submit 1 change due to the following problems:\n" +
+				"Change 123: submit requirement 'Code-Review' is unsatisfied."))
+
+		default:
+			_, _ = w.Write([]byte(changeJSON))
+		}
+	}))
+	t.Cleanup(srv.Close)
+
+	cfg := testConfig("")
+
+	cfg.GerritURL = srv.URL
+
+	client, err := gerritclient.New(t.Context(), cfg)
+	require.NoError(t, err)
+
+	_, err = client.SubmitChange(t.Context(), "123")
+
+	require.Error(t, err)
+	require.ErrorIs(t, err, gerritclient.ErrSubmitChange)
+	assert.ErrorContains(t, err, "submit requirement 'Code-Review' is unsatisfied")
+}