add remaining read-group tools

search_changes pages Gerrit queries and teaches the agent the core
operators in its description. list_change_files renders sorted
diffstat entries with binary and rename markers. get_file_diff
reconstructs unified-style prefixed lines with skip markers and a
bodyless binary form. get_change_comments rebuilds threads from reply
chains - chronological order, orphan replies as roots, resolution
taken from the last comment - and filters all/resolved/unresolved.

The read group now exposes all five change-read tools.

Refs: #7, #8, #9

Author: xobotyi

internal/registry/registry.go

@@ -15,7 +15,11 @@ import (
 func groupTools() map[config.Group][]string {
 	return map[config.Group][]string{
 		config.GroupRead: {
+			tools.NameSearchChanges,
 			tools.NameGetChange,
+			tools.NameListChangeFiles,
+			tools.NameGetFileDiff,
+			tools.NameGetChangeComments,
 		},
 		config.GroupComment:    {}, // arrives with the comment group implementation
 		config.GroupTransition: {}, // arrives with the transition group implementation

internal/registry/registry_test.go

@@ -19,9 +19,15 @@ func Test_Resolve(t *testing.T) {
 		want []string
 	}{
 		{
-			name: "read group exposes get_change",
+			name: "read group exposes the change-read tools",
 			give: []config.Group{config.GroupRead},
-			want: []string{tools.NameGetChange},
+			want: []string{
+				tools.NameSearchChanges,
+				tools.NameGetChange,
+				tools.NameListChangeFiles,
+				tools.NameGetFileDiff,
+				tools.NameGetChangeComments,
+			},
 		},
 		{
 			name: "no groups no tools",
@@ -31,7 +37,13 @@ func Test_Resolve(t *testing.T) {
 		{
 			name: "duplicate groups collapse",
 			give: []config.Group{config.GroupRead, config.GroupRead},
-			want: []string{tools.NameGetChange},
+			want: []string{
+				tools.NameSearchChanges,
+				tools.NameGetChange,
+				tools.NameListChangeFiles,
+				tools.NameGetFileDiff,
+				tools.NameGetChangeComments,
+			},
 		},
 		{
 			name: "write groups expose nothing yet",

internal/tools/get-change-comments.go

@@ -0,0 +1,235 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+
+	"dev.gaijin.team/go/golib/e"
+	gerrit "github.com/andygrunwald/go-gerrit"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/gerritclient"
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/llmxml"
+)
+
+// Thread status filter values.
+const (
+	statusAll        = "all"
+	statusResolved   = "resolved"
+	statusUnresolved = "unresolved"
+)
+
+var errInvalidStatus = e.New("invalid status filter, expected all, resolved, or unresolved")
+
+type getChangeCommentsInput struct {
+	Change string `json:"change" jsonschema:"Change identifier: numeric ID, project~number, or Change-Id"`
+	Status string `json:"status,omitempty" jsonschema:"Thread filter: all, resolved, or unresolved; default all"`
+}
+
+func getChangeComments(c *gerritclient.Client) Tool {
+	return Tool{
+		Name: NameGetChangeComments,
+		Register: func(s *mcp.Server) {
+			mcp.AddTool(s, &mcp.Tool{
+				Name: NameGetChangeComments,
+				Description: "List the published review comments of a Gerrit change, grouped by file " +
+					"and reconstructed into threads with their resolved state. Comment ids are the " +
+					"reply anchors for posting follow-ups.",
+			}, func(ctx context.Context, _ *mcp.CallToolRequest, in getChangeCommentsInput,
+			) (*mcp.CallToolResult, any, error) {
+				if in.Status == "" {
+					in.Status = statusAll
+				}
+
+				if in.Status != statusAll && in.Status != statusResolved && in.Status != statusUnresolved {
+					return nil, nil, errInvalidStatus.WithField("status", in.Status)
+				}
+
+				comments, err := c.ListChangeComments(ctx, in.Change)
+				if err != nil {
+					return nil, nil, err
+				}
+
+				return textResult(renderComments(in, comments)), nil, nil
+			})
+		},
+	}
+}
+
+// thread is one comment thread: the root comment and its replies in
+// chronological order. Its resolved state is the state of the last comment.
+type thread struct {
+	comments   []gerrit.CommentInfo
+	unresolved bool
+}
+
+// buildThreads reconstructs threads from a flat comment list. Comments are
+// ordered chronologically; each reply chain is walked to its root, and a
+// reply whose parent is missing starts its own thread.
+func buildThreads(comments []gerrit.CommentInfo) []thread {
+	ordered := make([]gerrit.CommentInfo, len(comments))
+	copy(ordered, comments)
+
+	slices.SortStableFunc(ordered, compareUpdated)
+
+	parent := make(map[string]string, len(ordered))
+	for _, comment := range ordered {
+		parent[comment.ID] = comment.InReplyTo
+	}
+
+	var (
+		roots   []string
+		grouped = map[string][]gerrit.CommentInfo{}
+	)
+
+	for _, comment := range ordered {
+		root := rootOf(parent, comment.ID)
+		if _, ok := grouped[root]; !ok {
+			roots = append(roots, root)
+		}
+
+		grouped[root] = append(grouped[root], comment)
+	}
+
+	threads := make([]thread, 0, len(roots))
+
+	for _, root := range roots {
+		group := grouped[root]
+		last := group[len(group)-1]
+
+		threads = append(threads, thread{
+			comments:   group,
+			unresolved: last.Unresolved != nil && *last.Unresolved,
+		})
+	}
+
+	return threads
+}
+
+func compareUpdated(a, b gerrit.CommentInfo) int {
+	switch {
+	case a.Updated == nil || b.Updated == nil:
+		return 0
+	case a.Updated.Before(b.Updated.Time):
+		return -1
+	case b.Updated.Before(a.Updated.Time):
+		return 1
+	default:
+		return 0
+	}
+}
+
+// rootOf walks a reply chain to its root; the iteration cap guards against
+// reference cycles in malformed data.
+func rootOf(parent map[string]string, id string) string {
+	for range len(parent) {
+		up, ok := parent[id]
+		if !ok || up == "" {
+			return id
+		}
+
+		id = up
+	}
+
+	return id
+}
+
+func matchesStatus(t thread, status string) bool {
+	switch status {
+	case statusResolved:
+		return !t.unresolved
+	case statusUnresolved:
+		return t.unresolved
+	default:
+		return true
+	}
+}
+
+func renderComments(in getChangeCommentsInput, byFile map[string][]gerrit.CommentInfo) string {
+	paths := make([]string, 0, len(byFile))
+	for path := range byFile {
+		paths = append(paths, path)
+	}
+
+	slices.Sort(paths)
+
+	var (
+		rendered    []string
+		threadCount int
+	)
+
+	for _, path := range paths {
+		threads := buildThreads(byFile[path])
+
+		var fileThreads []string
+
+		for _, t := range threads {
+			if !matchesStatus(t, in.Status) {
+				continue
+			}
+
+			threadCount++
+
+			fileThreads = append(fileThreads, renderThread(t))
+		}
+
+		if len(fileThreads) == 0 {
+			continue
+		}
+
+		rendered = append(rendered, llmxml.NewElement("file", llmxml.Attr("path", path)).
+			WrapText(strings.Join(fileThreads, "\n")).String())
+	}
+
+	root := llmxml.NewElement("comments",
+		llmxml.Attr("change", in.Change),
+		llmxml.Attr("filter", in.Status),
+		llmxml.Attr("threads", threadCount),
+	)
+
+	if len(rendered) == 0 {
+		return root.String()
+	}
+
+	return root.WrapText(strings.Join(rendered, "\n")).String()
+}
+
+func renderThread(t thread) string {
+	rendered := make([]string, 0, len(t.comments))
+
+	for _, comment := range t.comments {
+		el := llmxml.NewElement("comment",
+			llmxml.Attr("id", comment.ID),
+			llmxml.Attr("author", accountLabel(comment.Author)),
+		)
+
+		if comment.Updated != nil {
+			el.Attr(llmxml.Attr("date", timestamp(*comment.Updated)))
+		}
+
+		if comment.PatchSet > 0 {
+			el.Attr(llmxml.Attr("patch_set", comment.PatchSet))
+		}
+
+		if comment.Range != nil {
+			el.Attr(llmxml.Attr("lines", rangeLabel(comment.Range)))
+		} else if comment.Line > 0 {
+			el.Attr(llmxml.Attr("line", comment.Line))
+		}
+
+		if comment.InReplyTo != "" {
+			el.Attr(llmxml.Attr("in_reply_to", comment.InReplyTo))
+		}
+
+		rendered = append(rendered, el.WrapText(comment.Message).String())
+	}
+
+	return llmxml.NewElement("thread", llmxml.Attr("resolved", !t.unresolved)).
+		WrapText(strings.Join(rendered, "\n")).String()
+}
+
+func rangeLabel(r *gerrit.CommentRange) string {
+	return fmt.Sprintf("%d-%d", r.StartLine, r.EndLine)
+}

internal/tools/get-change_test.go

@@ -83,7 +83,7 @@ func session(t *testing.T, gerritHandler http.HandlerFunc) *mcp.ClientSession {
 func Test_GetChange(t *testing.T) {
 	t.Parallel()
 
-	t.Run("lists exactly one tool", func(t *testing.T) {
+	t.Run("lists all read tools", func(t *testing.T) {
 		t.Parallel()
 
 		cs := session(t, func(w http.ResponseWriter, _ *http.Request) {
@@ -93,8 +93,14 @@ func Test_GetChange(t *testing.T) {
 		res, err := cs.ListTools(t.Context(), nil)
 		require.NoError(t, err)
 
-		require.Len(t, res.Tools, 1)
-		assert.Equal(t, "get_change", res.Tools[0].Name)
+		names := make([]string, 0, len(res.Tools))
+		for _, tool := range res.Tools {
+			names = append(names, tool.Name)
+		}
+
+		assert.ElementsMatch(t, []string{
+			"search_changes", "get_change", "list_change_files", "get_file_diff", "get_change_comments",
+		}, names)
 	})
 
 	t.Run("renders change as llmxml", func(t *testing.T) {

internal/tools/get-file-diff.go

@@ -0,0 +1,81 @@
+package tools
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	gerrit "github.com/andygrunwald/go-gerrit"
+	"github.com/modelcontextprotocol/go-sdk/mcp"
+
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/gerritclient"
+	"dev.gaijin.team/go/go-gerrit-mcp/internal/llmxml"
+)
+
+type getFileDiffInput struct {
+	Change   string `json:"change" jsonschema:"Change identifier: numeric ID, project~number, or Change-Id"`
+	File     string `json:"file" jsonschema:"File path within the change; /COMMIT_MSG addresses the commit message"`
+	Revision string `json:"revision,omitempty" jsonschema:"Patch set number or SHA, defaults to current"`
+}
+
+func getFileDiff(c *gerritclient.Client) Tool {
+	return Tool{
+		Name: NameGetFileDiff,
+		Register: func(s *mcp.Server) {
+			mcp.AddTool(s, &mcp.Tool{
+				Name: NameGetFileDiff,
+				Description: "Fetch the diff of one file in a Gerrit change revision. Lines are " +
+					"prefixed unified-diff style: space for context, - for deleted, + for added.",
+			}, func(ctx context.Context, _ *mcp.CallToolRequest, in getFileDiffInput) (*mcp.CallToolResult, any, error) {
+				diff, err := c.GetDiff(ctx, in.Change, in.Revision, in.File)
+				if err != nil {
+					return nil, nil, err
+				}
+
+				return textResult(renderDiff(in, diff)), nil, nil
+			})
+		},
+	}
+}
+
+func renderDiff(in getFileDiffInput, diff *gerrit.DiffInfo) string {
+	root := llmxml.NewElement("diff",
+		llmxml.Attr("change", in.Change),
+		llmxml.Attr("revision", revisionLabel(in.Revision)),
+		llmxml.Attr("file", in.File),
+		llmxml.Attr("change_type", diff.ChangeType),
+	)
+
+	if diff.Binary {
+		root.Attr(llmxml.Attr("binary", true))
+
+		return root.String()
+	}
+
+	var b strings.Builder
+
+	for _, content := range diff.Content {
+		if content.Skip > 0 {
+			fmt.Fprintf(&b, "... %d common lines skipped ...\n", content.Skip)
+		}
+
+		writePrefixed(&b, " ", content.AB)
+		writePrefixed(&b, "-", content.A)
+		writePrefixed(&b, "+", content.B)
+	}
+
+	body := strings.TrimSuffix(b.String(), "\n")
+	if body == "" {
+		return root.String()
+	}
+
+	return root.WrapText(body).String()
+}
+
+func writePrefixed(b *strings.Builder, prefix string, lines []string) {
+	for _, line := range lines {
+		b.WriteString(prefix)
+		b.WriteString(line)
+		b.WriteByte('\n')
+	}
+}