Files
archie/internal/domain/workflow/remediate.go
T

156 lines
5.6 KiB
Go

package workflow
import (
"context"
"encoding/json"
"errors"
"fmt"
"strings"
"github.com/samcharles93/archie-core/internal/events"
)
// ErrNoReviewPayload is returned when a remediate run starts on a task that
// carries no review unit to address. The daemon reaction consumer is the
// only producer of Task.ReviewPayload; a remediate task without one is a
// dispatch bug upstream, not a recoverable condition here.
var ErrNoReviewPayload = errors.New("remediate: task carries no review payload")
// ReviewUnitComment is one actionable review comment the builder must
// address, carried inside a ReviewUnit.
type ReviewUnitComment struct {
CommentID int64 `json:"comment_id"`
Path string `json:"path,omitempty"`
Line int `json:"line,omitempty"`
Body string `json:"body"`
}
// ReviewUnit is the remediate workflow's input: one review and its actionable
// comments, decoded from Task.ReviewPayload.
type ReviewUnit struct {
ReviewID int64 `json:"review_id,omitempty"`
Author string `json:"author,omitempty"`
State string `json:"state,omitempty"`
// Body is the review's own top-level summary (e.g. a "requested_changes"
// review's message), separate from any inline comment bodies.
Body string `json:"body,omitempty"`
Comments []ReviewUnitComment `json:"comments,omitempty"`
}
// DecodeReviewUnit parses a task's ReviewPayload. An empty payload is
// ErrNoReviewPayload, not a zero-value unit: a remediate task with nothing
// to address should never have been dispatched.
func DecodeReviewUnit(payload string) (ReviewUnit, error) {
if payload == "" {
return ReviewUnit{}, ErrNoReviewPayload
}
var u ReviewUnit
if err := json.Unmarshal([]byte(payload), &u); err != nil {
return ReviewUnit{}, fmt.Errorf("decode review payload: %w", err)
}
return u, nil
}
// EncodeReviewUnit renders a review unit for storage in Task.ReviewPayload.
func EncodeReviewUnit(u ReviewUnit) (string, error) {
data, err := json.Marshal(u)
if err != nil {
return "", fmt.Errorf("encode review payload: %w", err)
}
return string(data), nil
}
// replyTarget is the one comment ID a remediation run's reply threads onto,
// and whether one exists at all. A standalone review with no inline
// comments (a plain "requested changes" message) has nothing to thread a
// reply onto, so the reply falls back to a plain PR comment.
func (u ReviewUnit) replyTarget() (int64, bool) {
for _, c := range u.Comments {
if c.CommentID > 0 {
return c.CommentID, true
}
}
return 0, false
}
// renderReviewUnitMission formats a review unit as the builder's mission
// input: the review's own message, if any, followed by every actionable
// comment with its location.
func renderReviewUnitMission(u ReviewUnit) string {
var b strings.Builder
if u.Body != "" {
fmt.Fprintf(&b, "Review summary (%s): %s\n\n", orUnknown(u.State), u.Body)
}
if len(u.Comments) == 0 {
b.WriteString("No inline comments were attached; address the review summary above.")
return b.String()
}
b.WriteString("Comments:\n")
for _, c := range u.Comments {
loc := "(general)"
if c.Path != "" {
loc = c.Path
if c.Line > 0 {
loc = fmt.Sprintf("%s:%d", c.Path, c.Line)
}
}
fmt.Fprintf(&b, "- %s: %s\n", loc, c.Body)
}
return b.String()
}
func orUnknown(s string) string {
if s == "" {
return "unspecified"
}
return s
}
// remediationRoundCapBytes bounds the round-cap park detail, matching the
// other clipped park reasons in this package.
const remediationRoundCapBytes = 2000
// StageRemediationRoundCap parks the task with a comment once
// Task.RemediationRounds reaches the cap; otherwise it counts the round.
func StageRemediationRoundCap() Stage {
return Stage{Name: "round-cap", Run: func(ctx context.Context, tc *TaskContext) error {
maxRounds := tc.Repo.EffectiveMaxRetries(tc.Cfg.MaxRetries)
if maxRounds > 0 && tc.Task.RemediationRounds >= maxRounds {
detail := fmt.Sprintf("remediation round cap reached (%d/%d); stopping and parking for an operator", tc.Task.RemediationRounds, maxRounds)
postRemediationComment(ctx, tc, "Archie has stopped remediating this review: "+detail+".")
tc.Outcome = Outcome{Status: StatusParked, Detail: clip(detail, remediationRoundCapBytes)}
return nil
}
tc.Task.RemediationRounds++
unit, _ := DecodeReviewUnit(tc.Task.ReviewPayload)
if err := tc.EmitDurable(ctx, events.KindRemediationRound, "round-cap",
fmt.Sprintf("remediation round %d answers review %d by %s", tc.Task.RemediationRounds, unit.ReviewID, unit.Author),
map[string]any{"round": tc.Task.RemediationRounds, "of": maxRounds, "review_id": unit.ReviewID, "author": unit.Author}); err != nil {
tc.Log.Warn("remediation round not recorded", "err", err)
}
return nil
}}
}
// postRemediationComment posts a plain PR comment, best-effort: a park or a
// reply failure on the messaging side must never mask the round-cap
// decision or the remediation outcome that already happened.
func postRemediationComment(ctx context.Context, tc *TaskContext, body string) {
if tc.Task.PRNumber <= 0 {
return
}
if _, err := tc.Forge.Comment(ctx, tc.Task.Owner, tc.Task.Repo, tc.Task.PRNumber, body); err != nil {
tc.Log.Warn("remediation comment not posted", "pr", tc.Task.PRNumber, "err", err)
}
}
// StageCheckReviewPayload fails the run before any worktree or agent work
// starts if the task's review payload cannot be decoded -- a dispatch bug
// upstream, not something a builder run can recover from.
func StageCheckReviewPayload() Stage {
return Stage{Name: "check-review-payload", Run: func(ctx context.Context, tc *TaskContext) error {
_, err := DecodeReviewUnit(tc.Task.ReviewPayload)
return err
}}
}