include the caller's drafts in comment threads

get_change_comments read only published comments, while the Gerrit UI
merges the viewer's unpublished drafts into thread state client-side.
An agent working for a user mid-review would declare every thread
resolved while the user's change screen showed dozens reopened by
their own pending drafts — both technically right, the agent wrong
about what the user sees.

The tool now fetches the caller's drafts alongside published comments
and merges them into reconstruction: draft comments render with
draft="true" and the authenticated account as author (Gerrit omits
author on drafts), the result carries a drafts count, and thread
resolved state matches the caller's UI.

Thread building now mirrors Gerrit 3.13 CommentThreads exactly:
comments pool change-wide by id instead of per file, so reply chains
survive file renames; reply branches merge chronologically with
comment-id tiebreak, which also decides the resolved state of threads
whose tail comments share a timestamp. Comments unreachable through
reference cycles surface as single-comment threads instead of being
dropped.

Fixes: #42

Author: xobotyi

internal/gerritclient/changes.go

@@ -19,6 +19,7 @@ var (
 	ErrListFiles    = e.New("list change files")
 	ErrGetDiff      = e.New("get file diff")
 	ErrListComments = e.New("list change comments")
+	ErrListDrafts   = e.New("list draft comments")
 
 	// ErrProjectScope reports an operation refused by the project allowlist.
 	ErrProjectScope = e.New("change is outside the configured project scope")
@@ -288,3 +289,23 @@ func (c *Client) ListChangeComments(ctx context.Context, changeID string) (map[s
 
 	return *comments, nil
 }
+
+// ListChangeDrafts lists the calling account's unpublished draft comments
+// across all revisions of a change, grouped by file path. Gerrit never
+// exposes other accounts' drafts.
+func (c *Client) ListChangeDrafts(ctx context.Context, changeID string) (map[string][]gerrit.CommentInfo, error) {
+	if err := c.checkProjectScope(ctx, changeID); err != nil {
+		return nil, ErrListDrafts.Wrap(err)
+	}
+
+	drafts, resp, err := c.gerrit.Changes.ListChangeDrafts(ctx, changeID)
+	if err != nil {
+		return nil, ErrListDrafts.Wrap(apiError(resp, err), fields.F("change", changeID))
+	}
+
+	if drafts == nil {
+		return nil, ErrListDrafts.Wrap(errEmptyResponse, fields.F("change", changeID))
+	}
+
+	return *drafts, nil
+}

internal/tools/get-change-comments.go

@@ -37,8 +37,11 @@ func getChangeComments(c *gerritclient.Client) Tool {
 				Description: "List a Gerrit change's inline review comments — the code discussion " +
 					"anchored to files and lines, distinct from the change messages get_change " +
 					"shows — grouped by file and reconstructed into threads with their resolved " +
-					"state. Comment ids are the reply anchors for post_comments; filter " +
-					"status=unresolved to see what still needs action.",
+					"state. The calling account's unpublished draft comments are included, marked " +
+					"draft=\"true\" and invisible to anyone else; thread state accounts for them, " +
+					"matching what this account's Gerrit UI shows. Comment ids are the reply " +
+					"anchors for post_comments; filter status=unresolved to see what still needs " +
+					"action.",
 			}, func(ctx context.Context, _ *mcp.CallToolRequest, in getChangeCommentsInput,
 			) (*mcp.CallToolResult, any, error) {
 				if in.Status == "" {
@@ -49,93 +52,199 @@ func getChangeComments(c *gerritclient.Client) Tool {
 					return nil, nil, errInvalidStatus.WithField("status", in.Status)
 				}
 
-				comments, err := c.ListChangeComments(ctx, in.Change)
+				published, err := c.ListChangeComments(ctx, in.Change)
 				if err != nil {
 					return nil, nil, err
 				}
 
-				return textResult(renderComments(in, comments)), nil, nil
+				drafts, err := c.ListChangeDrafts(ctx, in.Change)
+				if err != nil {
+					return nil, nil, err
+				}
+
+				all := flattenComments(published, drafts, accountLabel(c.Self()))
+
+				return textResult(renderComments(in, buildThreads(all), draftCount(all))), 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
+// changeComment is one comment of a change annotated with the file path it
+// anchors to and whether it is the caller's unpublished draft.
+type changeComment struct {
+	gerrit.CommentInfo
+
+	path        string
+	authorLabel string
+	draft       bool
+}
+
+// flattenComments merges the published and draft per-file comment maps into
+// one change-wide pool. Draft entries carry no author in Gerrit's response —
+// they are always the caller's — so they are labeled as self.
+func flattenComments(published, drafts map[string][]gerrit.CommentInfo, selfLabel string) []changeComment {
+	var all []changeComment
+
+	for path, comments := range published {
+		for _, ci := range comments {
+			all = append(all, changeComment{
+				CommentInfo: ci, path: path, authorLabel: accountLabel(ci.Author), draft: false,
+			})
+		}
+	}
+
+	for path, comments := range drafts {
+		for _, ci := range comments {
+			all = append(all, changeComment{
+				CommentInfo: ci, path: path, authorLabel: selfLabel, draft: true,
+			})
+		}
+	}
+
+	return all
 }
 
-// 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)
+func draftCount(all []changeComment) int {
+	count := 0
 
-	slices.SortStableFunc(ordered, compareUpdated)
+	for _, c := range all {
+		if c.draft {
+			count++
+		}
+	}
 
-	parent := make(map[string]string, len(ordered))
-	for _, comment := range ordered {
-		parent[comment.ID] = comment.InReplyTo
+	return count
+}
+
+// thread is one comment thread in Gerrit's order: root first, reply branches
+// merged chronologically with comment-id tiebreak. Its resolved state is the
+// state of the thread's last comment — drafts included, which is exactly the
+// state the caller's change screen shows.
+type thread struct {
+	comments   []changeComment
+	unresolved bool
+}
+
+// buildThreads reconstructs threads the way Gerrit 3.13 does
+// (CommentThreads): one change-wide pool keyed by comment id — reply chains
+// may cross file paths when a file was renamed between patch sets — where a
+// comment whose parent is absent from the pool roots its own thread.
+func buildThreads(all []changeComment) []thread {
+	byID := make(map[string]changeComment, len(all))
+	for _, c := range all {
+		byID[c.ID] = c
 	}
 
 	var (
-		roots   []string
-		grouped = map[string][]gerrit.CommentInfo{}
+		roots    []changeComment
+		children = map[string][]changeComment{}
 	)
 
-	for _, comment := range ordered {
-		root := rootOf(parent, comment.ID)
-		if _, ok := grouped[root]; !ok {
-			roots = append(roots, root)
+	for _, c := range all {
+		if c.InReplyTo != "" {
+			if _, ok := byID[c.InReplyTo]; ok {
+				children[c.InReplyTo] = append(children[c.InReplyTo], c)
+				continue
+			}
 		}
 
-		grouped[root] = append(grouped[root], comment)
+		roots = append(roots, c)
 	}
 
+	slices.SortStableFunc(roots, compareComments)
+
 	threads := make([]thread, 0, len(roots))
+	seen := 0
 
 	for _, root := range roots {
-		group := grouped[root]
-		last := group[len(group)-1]
+		members := expandThread(root, children)
+
+		seen += len(members)
+
+		last := members[len(members)-1]
 
 		threads = append(threads, thread{
-			comments:   group,
+			comments:   members,
 			unresolved: last.Unresolved != nil && *last.Unresolved,
 		})
 	}
 
+	// A reference cycle in malformed data leaves comments unreachable from
+	// any root; surface them as single-comment threads instead of dropping
+	// them silently.
+	if seen < len(all) {
+		threads = append(threads, orphanThreads(all, threads)...)
+	}
+
 	return threads
 }
 
-func compareUpdated(a, b gerrit.CommentInfo) int {
+// expandThread walks the reply tree from the root, always emitting the
+// earliest unvisited comment next, so parallel reply branches merge
+// chronologically while every parent stays ahead of its children.
+func expandThread(root changeComment, children map[string][]changeComment) []changeComment {
+	var members []changeComment
+
+	frontier := []changeComment{root}
+
+	for len(frontier) > 0 {
+		next := 0
+
+		for i := 1; i < len(frontier); i++ {
+			if compareComments(frontier[i], frontier[next]) < 0 {
+				next = i
+			}
+		}
+
+		c := frontier[next]
+
+		frontier = append(frontier[:next], frontier[next+1:]...)
+		members = append(members, c)
+		frontier = append(frontier, children[c.ID]...)
+	}
+
+	return members
+}
+
+// orphanThreads returns single-comment threads for comments that no built
+// thread contains.
+func orphanThreads(all []changeComment, threads []thread) []thread {
+	reached := map[string]bool{}
+
+	for _, t := range threads {
+		for _, c := range t.comments {
+			reached[c.ID] = true
+		}
+	}
+
+	var orphans []thread
+
+	for _, c := range all {
+		if !reached[c.ID] {
+			orphans = append(orphans, thread{
+				comments:   []changeComment{c},
+				unresolved: c.Unresolved != nil && *c.Unresolved,
+			})
+		}
+	}
+
+	return orphans
+}
+
+// compareComments orders comments chronologically, breaking ties (and absent
+// timestamps) by comment id — Gerrit's ordering, deterministic across runs.
+func compareComments(a, b changeComment) 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
+	return strings.Compare(a.ID, b.ID)
 }
 
 func matchesStatus(t thread, status string) bool {
@@ -149,7 +258,17 @@ func matchesStatus(t thread, status string) bool {
 	}
 }
 
-func renderComments(in getChangeCommentsInput, byFile map[string][]gerrit.CommentInfo) string {
+// renderComments groups threads under the file path of their root comment,
+// in sorted path order.
+func renderComments(in getChangeCommentsInput, threads []thread, drafts int) string {
+	byFile := map[string][]thread{}
+
+	for _, t := range threads {
+		path := t.comments[0].path
+
+		byFile[path] = append(byFile[path], t)
+	}
+
 	paths := make([]string, 0, len(byFile))
 	for path := range byFile {
 		paths = append(paths, path)
@@ -163,11 +282,9 @@ func renderComments(in getChangeCommentsInput, byFile map[string][]gerrit.Commen
 	)
 
 	for _, path := range paths {
-		threads := buildThreads(byFile[path])
-
 		var fileThreads []string
 
-		for _, t := range threads {
+		for _, t := range byFile[path] {
 			if !matchesStatus(t, in.Status) {
 				continue
 			}
@@ -189,6 +306,7 @@ func renderComments(in getChangeCommentsInput, byFile map[string][]gerrit.Commen
 		llmxml.Attr("change", in.Change),
 		llmxml.Attr("filter", in.Status),
 		llmxml.Attr("threads", threadCount),
+		llmxml.Attr("drafts", drafts),
 	)
 
 	if len(rendered) == 0 {
@@ -204,9 +322,13 @@ func renderThread(t thread) string {
 	for _, comment := range t.comments {
 		el := llmxml.NewElement("comment",
 			llmxml.Attr("id", comment.ID),
-			llmxml.Attr("author", accountLabel(comment.Author)),
+			llmxml.Attr("author", comment.authorLabel),
 		)
 
+		if comment.draft {
+			el.Attr(llmxml.Attr("draft", true))
+		}
+
 		if comment.Updated != nil {
 			el.Attr(llmxml.Attr("date", timestamp(*comment.Updated)))
 		}