add transition_change tool and transition group bundle

transition_change moves a change's state behind one action enum:
submit (NEW -> MERGED), abandon (NEW -> ABANDONED), restore
(ABANDONED -> NEW), wip, and ready. An optional message accompanies
every action except submit -- Gerrit's submit endpoint takes none, so
a message there is refused rather than dropped. The ack carries the
resulting status when the endpoint returns one; Gerrit refusals
(blocked submit) are reported verbatim.

The transition capability group bundles get_change, set_vote, and
transition_change -- the minimal read subset the flow needs to stand
on its own.

Refs: #17, #18

Author: xobotyi

internal/registry/registry.go

@@ -36,7 +36,13 @@ func groupTools() map[config.Group][]string {
 			tools.NameGetChangeComments,
 			tools.NamePostComments,
 		},
-		config.GroupTransition: {}, // arrives with the transition group implementation
+		// transition bundles the minimal read subset it needs: understanding
+		// the change whose state it moves.
+		config.GroupTransition: {
+			tools.NameGetChange,
+			tools.NameSetVote,
+			tools.NameTransitionChange,
+		},
 	}
 }
 

internal/registry/registry_test.go

@@ -84,11 +84,28 @@ func Test_Resolve(t *testing.T) {
 			want:        append(allReadTools(), tools.NamePostComments),
 		},
 		{
-			name:        "transition group exposes nothing yet",
+			name:        "transition group bundles its read subset",
 			giveGroups:  []config.Group{config.GroupTransition},
 			giveInclude: nil,
 			giveExclude: nil,
-			want:        nil,
+			want: []string{
+				tools.NameGetChange,
+				tools.NameSetVote,
+				tools.NameTransitionChange,
+			},
+		},
+		{
+			name:        "comment and transition union deduplicates",
+			giveGroups:  []config.Group{config.GroupComment, config.GroupTransition},
+			giveInclude: nil,
+			giveExclude: nil,
+			want: []string{
+				tools.NameGetChange,
+				tools.NameGetChangeComments,
+				tools.NamePostComments,
+				tools.NameSetVote,
+				tools.NameTransitionChange,
+			},
 		},
 		{
 			name:        "exclude removes tools",

internal/tools/get-change_test.go

@@ -104,7 +104,7 @@ func Test_GetChange(t *testing.T) {
 
 		assert.ElementsMatch(t, []string{
 			"search_changes", "get_change", "list_change_files", "get_file_diff", "get_change_comments",
-			"post_comments", "set_vote",
+			"post_comments", "set_vote", "transition_change",
 		}, names)
 	})
 

internal/tools/tools.go

@@ -18,6 +18,7 @@ const (
 	NameGetChangeComments = "get_change_comments"
 	NamePostComments      = "post_comments"
 	NameSetVote           = "set_vote"
+	NameTransitionChange  = "transition_change"
 )
 
 // Tool binds a tool name to its MCP registration.
@@ -37,6 +38,7 @@ func All(c *gerritclient.Client) []Tool {
 		getChangeComments(c),
 		postComments(c),
 		setVote(c),
+		transitionChange(c),
 	}
 }
 

internal/tools/transition-change.go

@@ -0,0 +1,102 @@
+package tools
+
+import (
+	"context"
+	"strings"
+
+	"dev.gaijin.team/go/golib/e"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/gerritclient"
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/llmxml"
+)
+
+var (
+	errUnknownAction = e.New("unknown action, expected submit, abandon, restore, wip, or ready")
+	errSubmitMessage = e.New("submit does not accept a message; vote or comment separately")
+)
+
+type transitionChangeInput struct {
+	Change  string `json:"change" jsonschema:"Change identifier: numeric ID, project~number, or Change-Id"`
+	Action  string `json:"action" jsonschema:"One of: submit, abandon, restore, wip, ready"`
+	Message string `json:"message,omitempty" jsonschema:"Optional message; not accepted for submit"`
+}
+
+func transitionChange(c *gerritclient.Client) Tool {
+	return Tool{
+		Name: NameTransitionChange,
+		Register: func(s *mcp.Server) {
+			mcp.AddTool(s, &mcp.Tool{
+				Name: NameTransitionChange,
+				Description: "Transition a Gerrit change's state. Actions and the states they move " +
+					"between: submit (NEW -> MERGED, requires satisfied submit requirements), " +
+					"abandon (NEW -> ABANDONED), restore (ABANDONED -> NEW), wip (marks NEW change " +
+					"work-in-progress), ready (work-in-progress -> ready for review). An optional " +
+					"message accompanies every action except submit. Gerrit's refusal (blocked " +
+					"submit, restore of a merged change) is reported verbatim. Refused on changes " +
+					"not owned by the authenticated account unless the operator disabled the " +
+					"own-changes restriction.",
+			}, func(ctx context.Context, _ *mcp.CallToolRequest, in transitionChangeInput,
+			) (*mcp.CallToolResult, any, error) {
+				action := strings.ToLower(strings.TrimSpace(in.Action))
+
+				status, err := runTransition(ctx, c, action, in)
+				if err != nil {
+					return nil, nil, err
+				}
+
+				attrs := []llmxml.Attribute{
+					llmxml.Attr("change", in.Change),
+					llmxml.Attr("action", action),
+				}
+				if status != "" {
+					attrs = append(attrs, llmxml.Attr("status", status))
+				}
+
+				return textResult(llmxml.NewElement("change_transitioned", attrs...).String()), nil, nil
+			})
+		},
+	}
+}
+
+// runTransition maps the action enum onto the client operation and reports
+// the change status when the endpoint returns one.
+func runTransition(ctx context.Context, c *gerritclient.Client, action string, in transitionChangeInput,
+) (string, error) {
+	switch action {
+	case "submit":
+		if strings.TrimSpace(in.Message) != "" {
+			return "", errSubmitMessage
+		}
+
+		info, err := c.SubmitChange(ctx, in.Change)
+		if err != nil {
+			return "", err
+		}
+
+		return info.Status, nil
+
+	case "abandon":
+		info, err := c.AbandonChange(ctx, in.Change, in.Message)
+		if err != nil {
+			return "", err
+		}
+
+		return info.Status, nil
+
+	case "restore":
+		info, err := c.RestoreChange(ctx, in.Change, in.Message)
+		if err != nil {
+			return "", err
+		}
+
+		return info.Status, nil
+
+	case "wip":
+		return "", c.SetWorkInProgress(ctx, in.Change, in.Message)
+	case "ready":
+		return "", c.SetReadyForReview(ctx, in.Change, in.Message)
+	default:
+		return "", errUnknownAction.WithField("action", in.Action)
+	}
+}