relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/beads/comments_test.go

@@ -0,0 +1,242 @@
+package beads
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/task/beads/bdcli"
+)
+
+func TestHasCommentFindsMarkerOnParentOrMailbox(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		target    task.Target
+		issueID   string
+		wantFound bool
+	}{
+		{
+			name:      "parent summary",
+			target:    task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}},
+			issueID:   "demo-parent",
+			wantFound: true,
+		},
+		{
+			name: "mailbox feedback",
+			target: task.Target{
+				Parent:  task.TicketRef{ID: "demo-parent", Key: "demo-parent"},
+				Mailbox: &task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"},
+			},
+			issueID:   "demo-parent.1",
+			wantFound: true,
+		},
+		{
+			name:      "missing marker",
+			target:    task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}},
+			issueID:   "demo-parent",
+			wantFound: false,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			client := &commentClient{comments: map[string][]bdcli.Comment{
+				"demo-parent": {
+					{ID: "comment-parent", Text: "parent note\n<!-- visit-parent:summary -->"},
+				},
+				"demo-parent.1": {
+					{ID: "comment-mailbox", Text: "feedback\n<!-- visit-mailbox:feedback -->"},
+				},
+			}}
+			marker := "visit-parent:summary"
+			if tc.name == "mailbox feedback" {
+				marker = "visit-mailbox:feedback"
+			}
+			if tc.name == "missing marker" {
+				marker = "visit-missing:summary"
+			}
+			sys := &system{cli: client}
+			got, err := sys.HasComment(context.Background(), tc.target, marker)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got != tc.wantFound {
+				t.Fatalf("HasComment = %v, want %v", got, tc.wantFound)
+			}
+			if !reflect.DeepEqual(client.listed, []string{tc.issueID}) {
+				t.Fatalf("comment lookup IDs = %v, want [%s]", client.listed, tc.issueID)
+			}
+		})
+	}
+}
+
+func TestCommentAvoidsDuplicateMarkerAndPreservesMultilineBody(t *testing.T) {
+	marker := "visit-1:summary"
+	target := task.Target{
+		Parent:  task.TicketRef{ID: "demo-parent", Key: "demo-parent"},
+		Mailbox: &task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"},
+	}
+	client := &commentClient{comments: map[string][]bdcli.Comment{
+		"demo-parent.1": {{ID: "existing", Text: "already stored\n<!-- " + marker + " -->"}},
+	}}
+	sys := &system{cli: client}
+
+	if err := sys.Comment(context.Background(), target, "SUMMARY:\nfirst line\nsecond line", marker); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.added) != 0 {
+		t.Fatalf("duplicate marker caused comment write: %+v", client.added)
+	}
+
+	client.comments[target.Mailbox.Key] = nil
+	body := "SUMMARY:\nfirst line\nsecond line"
+	if err := sys.Comment(context.Background(), target, body, marker); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.added) != 1 {
+		t.Fatalf("comment writes = %+v, want one", client.added)
+	}
+	if client.added[0].issueID != target.Mailbox.Key {
+		t.Fatalf("comment destination = %q, want %q", client.added[0].issueID, target.Mailbox.Key)
+	}
+	wantBody := body + "\n\n<!-- " + marker + " -->"
+	if client.added[0].body != wantBody {
+		t.Fatalf("comment body = %q, want %q", client.added[0].body, wantBody)
+	}
+	if !strings.Contains(client.added[0].body, "first line\nsecond line") {
+		t.Fatalf("multiline content was not preserved: %q", client.added[0].body)
+	}
+}
+
+func TestCommentUsesSummaryAndSelectedFeedbackMailboxDestinations(t *testing.T) {
+	client := &commentClient{comments: map[string][]bdcli.Comment{}}
+	sys := &system{cli: client}
+	parent := task.TicketRef{ID: "demo-parent", Key: "demo-parent"}
+	current := &task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"}
+	selectedNext := &task.Mailbox{ID: "demo-parent.2", Key: "demo-parent.2", Node: "review"}
+
+	if err := sys.Comment(context.Background(), task.Target{Parent: parent, Mailbox: current}, "summary", "visit-1:summary"); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.Comment(context.Background(), task.Target{Parent: parent, Mailbox: selectedNext}, "feedback", "visit-1:feedback"); err != nil {
+		t.Fatal(err)
+	}
+	got := []string{client.added[0].issueID, client.added[1].issueID}
+	want := []string{current.Key, selectedNext.Key}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("comment destinations = %v, want %v", got, want)
+	}
+}
+
+func TestBeadsRenderTextExposesSupportedTemplateValues(t *testing.T) {
+	sys := &system{effective: Config{Templates: Templates{
+		MailboxDescription: "mailbox {{runID}}|{{ticket}}|{{workflow}}|{{repo}}|{{node}}|{{nodeType}}|{{agent}}|{{nodeDescription}}|{{nextSteps}}|{{successRoutes}}|{{failureRoutes}}|{{mailbox}}",
+		SummaryComment:     "summary {{sourceNode}}|{{targetNode}}|{{mailbox}}|{{summaryReport}}",
+		FeedbackComment:    "feedback {{sourceNode}}|{{targetNode}}|{{mailbox}}|{{feedbackReport}}",
+	}}}
+	data := task.TextData{
+		RunID:           "run-1",
+		Ticket:          "demo-parent",
+		Workflow:        "implementation",
+		Repo:            "payments",
+		Node:            "review",
+		NodeType:        "hitl",
+		Agent:           "reviewer",
+		NodeDescription: "Review the change.",
+		NextSteps:       "implement; end",
+		SuccessRoutes:   "end",
+		FailureRoutes:   "implement",
+		Mailbox:         "demo-parent.2",
+		SourceNode:      "review",
+		TargetNode:      "implement",
+		SummaryReport:   "COMPLETED:\nreviewed",
+		FeedbackReport:  "REQUIRED ACTIONS:\nfix it",
+	}
+
+	description, err := sys.RenderText(task.TextMailboxDescription, data)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{
+		"run-1", "demo-parent", "implementation", "payments", "review", "hitl", "reviewer",
+		"Review the change.", "implement; end", "end", "implement", "demo-parent.2",
+	} {
+		if !strings.Contains(description, want) {
+			t.Fatalf("mailbox description missing %q: %q", want, description)
+		}
+	}
+
+	summary, err := sys.RenderText(task.TextSummaryComment, data)
+	if err != nil || !strings.Contains(summary, data.SummaryReport) || !strings.Contains(summary, "review|implement|demo-parent.2") {
+		t.Fatalf("summary = %q, %v", summary, err)
+	}
+	feedback, err := sys.RenderText(task.TextFeedbackComment, data)
+	if err != nil || !strings.Contains(feedback, data.FeedbackReport) || !strings.Contains(feedback, "review|implement|demo-parent.2") {
+		t.Fatalf("feedback = %q, %v", feedback, err)
+	}
+}
+
+func TestBeadsTemplateValidationRequiresReportPlaceholders(t *testing.T) {
+	for _, tc := range []struct {
+		name      string
+		templates Templates
+		wantError string
+	}{
+		{
+			name: "summary report",
+			templates: Templates{
+				SummaryComment:  "summary",
+				FeedbackComment: "feedback {{feedbackReport}}",
+			},
+			wantError: "summaryComment must contain {{summaryReport}}",
+		},
+		{
+			name: "feedback report",
+			templates: Templates{
+				SummaryComment:  "summary {{summaryReport}}",
+				FeedbackComment: "feedback",
+			},
+			wantError: "feedbackComment must contain {{feedbackReport}}",
+		},
+		{
+			name: "unknown variable",
+			templates: Templates{
+				MailboxDescription: "mailbox {{mailboxInstructions}}",
+				SummaryComment:     "summary {{summaryReport}}",
+				FeedbackComment:    "feedback {{feedbackReport}}",
+			},
+			wantError: "unknown template variable {{mailboxInstructions}}",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			err := validateTemplates(tc.templates)
+			if err == nil || !strings.Contains(err.Error(), tc.wantError) {
+				t.Fatalf("validateTemplates error = %v, want %q", err, tc.wantError)
+			}
+		})
+	}
+}
+
+type commentClient struct {
+	mailboxClient
+	comments map[string][]bdcli.Comment
+	listed   []string
+	added    []addedComment
+}
+
+type addedComment struct {
+	issueID string
+	body    string
+}
+
+func (f *commentClient) ListComments(_ context.Context, issueID string) ([]bdcli.Comment, error) {
+	f.listed = append(f.listed, issueID)
+	return append([]bdcli.Comment(nil), f.comments[issueID]...), nil
+}
+
+func (f *commentClient) AddComment(_ context.Context, issueID, body string) error {
+	f.added = append(f.added, addedComment{issueID: issueID, body: body})
+	return nil
+}
+
+var _ bdcli.Client = (*commentClient)(nil)

package/internal/task/beads/config_compatibility_test.go

@@ -0,0 +1,163 @@
+package beads
+
+import (
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+func TestBeadsConfigAcceptsSharedTransitionAndAssignee(t *testing.T) {
+	err := task.ValidateTextConfig("beads", config.RawValues{
+		"assignee": "owner@example.com",
+		"filters": map[string]any{
+			"parentStatuses": []any{"open"},
+			"issueTypes":     []any{"epic"},
+			"labels":         []any{"relay-ready"},
+			"assignees":      []any{"owner@example.com"},
+		},
+		"transitionTo": map[string]any{
+			"parentStatus": "in_progress",
+			"taskStatus":   "closed",
+		},
+	})
+	if err != nil {
+		t.Fatalf("shared transitionTo and assignee configuration was rejected: %v", err)
+	}
+}
+
+func TestBeadsConfigRejectsLegacyStatusVocabulary(t *testing.T) {
+	for _, field := range []string{"parent", "mailbox"} {
+		t.Run(field, func(t *testing.T) {
+			err := task.ValidateTextConfig("beads", config.RawValues{
+				"status": map[string]any{field: "open"},
+			})
+			if err == nil {
+				t.Fatalf("legacy status.%s configuration was accepted", field)
+			}
+		})
+	}
+}
+
+func TestBeadsConfigRejectsJiraOnlyFields(t *testing.T) {
+	for _, field := range []string{"project", "component"} {
+		t.Run(field, func(t *testing.T) {
+			err := task.ValidateTextConfig("beads", config.RawValues{field: "not-supported"})
+			if err == nil {
+				t.Fatalf("Jira-only field %q was accepted", field)
+			}
+		})
+	}
+}
+
+func TestBeadsCompileFilterUsesInheritedTopLevelAssignee(t *testing.T) {
+	sys := &system{base: config.Merge(DefaultConfig(), config.RawValues{
+		"assignee": "Repo.Bot@Example.com",
+	})}
+	match, err := sys.CompileFilter(nil)
+	if err != nil {
+		t.Fatalf("CompileFilter failed: %v", err)
+	}
+	if !match(task.Ticket{Fields: map[string]any{"assignee": "repo.bot@example.COM"}}) {
+		t.Fatal("top-level assignee did not become the default filter")
+	}
+	if match(task.Ticket{Fields: map[string]any{"assignee": "other@example.com"}}) {
+		t.Fatal("ticket assigned to another user matched the default assignee filter")
+	}
+}
+
+func TestBeadsExplicitAssigneeFilterOverridesInheritedDefault(t *testing.T) {
+	sys := &system{base: config.Merge(DefaultConfig(), config.RawValues{
+		"assignee": "repo@example.com",
+	})}
+	match, err := sys.CompileFilter(config.RawValues{
+		"assignee": "workflow@example.com",
+		"filters": map[string]any{
+			"assignees": []any{"selected@example.com"},
+		},
+	})
+	if err != nil {
+		t.Fatalf("CompileFilter failed: %v", err)
+	}
+	if !match(task.Ticket{Fields: map[string]any{"assignee": "SELECTED@example.com"}}) {
+		t.Fatal("explicit assignee filter rejected the selected assignee")
+	}
+	for _, assignee := range []string{"repo@example.com", "workflow@example.com"} {
+		if match(task.Ticket{Fields: map[string]any{"assignee": assignee}}) {
+			t.Fatalf("inherited assignee %q overrode explicit assignee filter", assignee)
+		}
+	}
+}
+
+func TestBeadsConfigPreservesRootRepoWorkflowNodePrecedence(t *testing.T) {
+	root := config.RawValues{
+		"assignee": "root@example.com",
+		"filters": map[string]any{
+			"parentStatuses": []any{"root"},
+			"labels":         []any{"root-label"},
+		},
+		"transitionTo": map[string]any{
+			"parentStatus": "open",
+			"taskStatus":   "open",
+		},
+	}
+	repo := config.RawValues{
+		"assignee": "repo@example.com",
+		"filters": map[string]any{
+			"parentStatuses": []any{"repo"},
+		},
+		"transitionTo": map[string]any{
+			"parentStatus": "in_progress",
+		},
+	}
+	workflow := config.RawValues{
+		"assignee": "workflow@example.com",
+		"filters": map[string]any{
+			"issueTypes": []any{"workflow-type"},
+		},
+		"transitionTo": map[string]any{
+			"taskStatus": "in_progress",
+		},
+	}
+	node := config.RawValues{
+		"assignee": "node@example.com",
+		"filters": map[string]any{
+			"labels": []any{"node-label"},
+		},
+		"transitionTo": map[string]any{
+			"taskStatus": "closed",
+		},
+	}
+
+	merged := config.Merge(root, repo, workflow, node)
+	if merged["assignee"] != "node@example.com" {
+		t.Fatalf("merged assignee = %v, want node value", merged["assignee"])
+	}
+	transition, ok := merged["transitionTo"].(map[string]any)
+	if !ok {
+		t.Fatalf("merged transitionTo = %#v, want map", merged["transitionTo"])
+	}
+	if transition["parentStatus"] != "in_progress" {
+		t.Fatalf("merged parent status = %v, want repo value", transition["parentStatus"])
+	}
+	if transition["taskStatus"] != "closed" {
+		t.Fatalf("merged task status = %v, want node value", transition["taskStatus"])
+	}
+	filters, ok := merged["filters"].(map[string]any)
+	if !ok {
+		t.Fatalf("merged filters = %#v, want map", merged["filters"])
+	}
+	if got := filters["parentStatuses"].([]any); len(got) != 1 || got[0] != "repo" {
+		t.Fatalf("merged parent statuses = %#v, want repo value", filters["parentStatuses"])
+	}
+	if got := filters["issueTypes"].([]any); len(got) != 1 || got[0] != "workflow-type" {
+		t.Fatalf("merged issue types = %#v, want workflow value", filters["issueTypes"])
+	}
+	if got := filters["labels"].([]any); len(got) != 1 || got[0] != "node-label" {
+		t.Fatalf("merged labels = %#v, want node value", filters["labels"])
+	}
+
+	if err := task.ValidateTextConfig("beads", merged); err != nil {
+		t.Fatalf("effective root/repo/workflow/node configuration was rejected: %v", err)
+	}
+}

package/internal/task/beads/lifecycle_inheritance_test.go

@@ -0,0 +1,168 @@
+package beads
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/task/beads/bdcli"
+)
+
+// Inherited root/repository taskConfig must have the same effect at runtime
+// that validation implies. ApplyTaskConfig receives only the configuration the
+// caller assembles (lifecycle defaults merged under workflow/node values), so
+// an adapter that keeps inherited values to itself accepts configuration,
+// validates it, and then silently discards it.
+//
+// The adapter therefore returns its inherited transitionTo/assignee values as
+// part of its lifecycle defaults, producing the effective precedence
+// built-in default < root < repo < workflow < node.
+//
+// internal/task/jira/lifecycle_inheritance_test.go is the sibling of this file
+// and asserts the same invariants against the Jira adapter. Keep the two in
+// sync: a change that breaks inheritance in one adapter must fail here too.
+
+// repoScopedSystem builds the adapter with root/repository-scoped values, the
+// scopes that never appear in an ApplyTaskConfig argument.
+func repoScopedSystem(client bdcli.Client, repoValues config.RawValues) *system {
+	return &system{cli: client, base: config.Merge(DefaultConfig(), repoValues)}
+}
+
+// operationConfig reproduces what the caller assembles before ApplyTaskConfig.
+func operationConfig(defaults, workflow, node config.RawValues) config.RawValues {
+	return config.Merge(defaults, config.Merge(workflow, node))
+}
+
+func lifecycleDefaultsOf(t *testing.T, sys task.System) task.LifecycleDefaults {
+	t.Helper()
+	d, ok := sys.(task.LifecycleDefaults)
+	if !ok {
+		t.Fatal("adapter does not expose task.LifecycleDefaults; inherited values cannot reach runtime")
+	}
+	return d
+}
+
+func TestLifecycleDefaultsCarryInheritedTransitionTo(t *testing.T) {
+	t.Run("repo parentStatus reaches start", func(t *testing.T) {
+		client := newStatusClient(map[string]string{"demo-parent": "open"})
+		sys := repoScopedSystem(client, config.RawValues{
+			"transitionTo": map[string]any{"parentStatus": "blocked"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).StartDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), endTarget(), cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(client.updates) != 1 || client.updates[0].input.Status != "blocked" {
+			t.Fatalf("updates = %+v, want the inherited repo value to beat the built-in default", client.updates)
+		}
+	})
+
+	t.Run("repo taskStatus reaches a work node", func(t *testing.T) {
+		client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+		sys := repoScopedSystem(client, config.RawValues{
+			"transitionTo": map[string]any{"taskStatus": "blocked"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(client.updates) != 1 || client.updates[0].input.Status != "blocked" {
+			t.Fatalf("updates = %+v, want the inherited repo value to beat the built-in default", client.updates)
+		}
+	})
+}
+
+func TestLifecycleDefaultsCarryInheritedAssignee(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+	sys := repoScopedSystem(client, config.RawValues{"assignee": "repo-bot@example.com"})
+	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+	if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 1 {
+		t.Fatalf("updates = %+v, want one combined update", client.updates)
+	}
+	update := client.updates[0].input
+	if update.Status != "in_progress" || update.Assignee != "repo-bot@example.com" {
+		t.Fatalf("update = %+v, want the built-in status plus the inherited repo assignee", update)
+	}
+}
+
+func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
+	for _, tc := range []struct {
+		name     string
+		workflow config.RawValues
+		node     config.RawValues
+		want     string
+	}{
+		{name: "repo beats built-in default", want: "blocked"},
+		{
+			name:     "workflow beats repo",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "hooked"}},
+			want:     "hooked",
+		},
+		{
+			name:     "node beats workflow",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "hooked"}},
+			node:     config.RawValues{"transitionTo": map[string]any{"taskStatus": "deferred"}},
+			want:     "deferred",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			client := newStatusClient(map[string]string{"demo-parent.1": "open"})
+			sys := repoScopedSystem(client, config.RawValues{
+				"transitionTo": map[string]any{"taskStatus": "blocked"},
+			})
+			cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), tc.workflow, tc.node)
+
+			if err := sys.ApplyTaskConfig(context.Background(), statusTarget("demo-parent.1"), cfg); err != nil {
+				t.Fatal(err)
+			}
+			if len(client.updates) != 1 || client.updates[0].input.Status != tc.want {
+				t.Fatalf("updates = %+v, want [%s]", client.updates, tc.want)
+			}
+		})
+	}
+}
+
+// With nothing inherited, the built-in lifecycle values still apply: the
+// parent opens the run in_progress, a work mailbox moves to in_progress, and
+// the parent closes at end.
+func TestLifecycleDefaultsWithoutInheritedValues(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open", "demo-parent.1": "open"})
+	sys := repoScopedSystem(client, nil)
+	d := lifecycleDefaultsOf(t, sys)
+	ctx := context.Background()
+
+	if err := sys.ApplyTaskConfig(ctx, endTarget(), operationConfig(d.StartDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(ctx, statusTarget("demo-parent.1"), operationConfig(d.WorkDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(ctx, endTarget(), operationConfig(d.EndDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+
+	want := []struct{ issueID, status string }{
+		{"demo-parent", "in_progress"},
+		{"demo-parent.1", "in_progress"},
+		{"demo-parent", "closed"},
+	}
+	if len(client.updates) != len(want) {
+		t.Fatalf("updates = %+v, want %d lifecycle updates", client.updates, len(want))
+	}
+	for i, expected := range want {
+		got := client.updates[i]
+		if got.issueID != expected.issueID || got.input.Status != expected.status {
+			t.Fatalf("update %d = %+v, want %s -> %s", i, got, expected.issueID, expected.status)
+		}
+		if got.input.Assignee != "" {
+			t.Fatalf("update %d assigned %q with no assignee configured", i, got.input.Assignee)
+		}
+	}
+}