relay-flow 0.2.0-alpha → 0.2.2-alpha

package/internal/task/beads/status_test.go

@@ -0,0 +1,257 @@
+package beads
+
+import (
+	"context"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/retry"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/task/beads/bdcli"
+)
+
+func TestApplyTaskConfigExpectedMailboxStateUsesUnconditionalUpdate(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+	sys := &system{cli: client}
+	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"},
+	}
+
+	err := sys.ApplyTaskConfig(context.Background(), target, config.RawValues{
+		"transitionTo": map[string]any{"taskStatus": "closed"},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(client.shown, []string{"demo-parent.1"}) {
+		t.Fatalf("show calls = %v, want one mailbox read", client.shown)
+	}
+	if len(client.updates) != 1 {
+		t.Fatalf("updates = %+v, want one unconditional status update", client.updates)
+	}
+	update := client.updates[0]
+	if update.issueID != "demo-parent.1" || update.input.Status != "closed" {
+		t.Fatalf("status update = %+v", update)
+	}
+	if update.input.Description != nil || len(update.input.AddLabels) != 0 || update.input.ClearDefer || update.input.Assignee != "" {
+		t.Fatalf("status update carried unrelated flags: %+v", update.input)
+	}
+}
+
+func TestApplyTaskConfigAlreadyAtTargetIsIdempotent(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "closed"})
+	sys := &system{cli: client}
+	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"},
+	}
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, config.RawValues{
+		"transitionTo": map[string]any{"taskStatus": "closed"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != "demo-parent.1" {
+		t.Fatalf("show calls = %v, want one target-state read", client.shown)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("already-target status issued updates: %+v", client.updates)
+	}
+}
+
+func TestApplyTaskConfigWithoutStatusIsNoOp(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open"})
+	sys := &system{cli: client}
+	target := task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}}
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, nil); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 0 || len(client.updates) != 0 {
+		t.Fatalf("no-status config caused calls: show=%v updates=%+v", client.shown, client.updates)
+	}
+}
+
+func TestApplyTaskConfigIncompatibleMailboxStateReturnsConflict(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_review"})
+	sys := &system{cli: client}
+	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"},
+	}
+
+	err := sys.ApplyTaskConfig(context.Background(), target, config.RawValues{
+		"transitionTo": map[string]any{"taskStatus": "closed"},
+	})
+	if err == nil {
+		t.Fatal("incompatible mailbox state was accepted")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("incompatible state issued a status update: %+v", client.updates)
+	}
+}
+
+func TestApplyTaskConfigParentStatusUsesReadBeforeWrite(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent": "open"})
+	sys := &system{cli: client}
+	target := task.Target{Parent: task.TicketRef{ID: "demo-parent", Key: "demo-parent"}}
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, config.RawValues{
+		"transitionTo": map[string]any{"parentStatus": "closed"},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(client.shown, []string{"demo-parent"}) {
+		t.Fatalf("show calls = %v, want one parent read", client.shown)
+	}
+	if len(client.updates) != 1 || client.updates[0].issueID != "demo-parent" || client.updates[0].input.Status != "closed" {
+		t.Fatalf("parent status updates = %+v", client.updates)
+	}
+}
+
+func TestCompleteMailboxUsesReadBeforeWriteAndIsIdempotent(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+	sys := &system{cli: client}
+	mailbox := task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"}
+
+	if err := sys.CompleteMailbox(context.Background(), mailbox); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || client.shown[0] != mailbox.Key || len(client.updates) != 1 || client.updates[0].input.Status != "closed" {
+		t.Fatalf("completion calls = show:%v updates:%+v", client.shown, client.updates)
+	}
+
+	client.shown = nil
+	client.updates = nil
+	client.issues[mailbox.Key] = bdcli.Issue{ID: mailbox.Key, Status: "closed"}
+	if err := sys.CompleteMailbox(context.Background(), mailbox); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.shown) != 1 || len(client.updates) != 0 {
+		t.Fatalf("already-closed completion calls = show:%v updates:%+v", client.shown, client.updates)
+	}
+}
+
+func TestCompleteMailboxIncompatibleStateReturnsConflictWithoutUpdate(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_review"})
+	sys := &system{cli: client}
+	mailbox := task.Mailbox{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"}
+
+	err := sys.CompleteMailbox(context.Background(), mailbox)
+	if err == nil {
+		t.Fatal("incompatible mailbox completion was accepted")
+	}
+	if got := retry.Classify(err).Kind; got != retry.Conflict {
+		t.Fatalf("failure kind = %q, want conflict: %v", got, err)
+	}
+	if len(client.updates) != 0 {
+		t.Fatalf("incompatible completion issued update: %+v", client.updates)
+	}
+}
+
+func TestStatusRaceAfterReadUsesOneUnconditionalUpdate(t *testing.T) {
+	client := newStatusClient(map[string]string{"demo-parent.1": "in_progress"})
+	client.beforeUpdate = func(issueID string) {
+		client.issues[issueID] = bdcli.Issue{ID: issueID, Status: "in_review"}
+	}
+	sys := &system{cli: client}
+	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"},
+	}
+
+	if err := sys.ApplyTaskConfig(context.Background(), target, config.RawValues{
+		"transitionTo": map[string]any{"taskStatus": "closed"},
+	}); err != nil {
+		t.Fatalf("accepted read/write race returned error: %v", err)
+	}
+	if len(client.shown) != 1 || len(client.updates) != 1 {
+		t.Fatalf("race calls = show:%v updates:%+v, want one read and one write", client.shown, client.updates)
+	}
+	if client.updates[0].input.Status != "closed" {
+		t.Fatalf("race update = %+v", client.updates[0])
+	}
+}
+
+func TestResetForRecoveryReopensParentAndMailboxesAndClearsDefer(t *testing.T) {
+	client := newStatusClient(map[string]string{
+		"demo-parent":   "blocked",
+		"demo-parent.1": "closed",
+		"demo-parent.2": "deferred",
+	})
+	sys := &system{cli: client}
+	parent := task.TicketRef{ID: "demo-parent", Key: "demo-parent", Title: "parent"}
+	mailboxes := []task.Mailbox{
+		{ID: "demo-parent.1", Key: "demo-parent.1", Node: "implement"},
+		{ID: "demo-parent.2", Key: "demo-parent.2", Node: "review"},
+	}
+
+	if err := sys.ResetForRecovery(context.Background(), parent, mailboxes, nil); err != nil {
+		t.Fatal(err)
+	}
+	if len(client.updates) != 3 {
+		t.Fatalf("recovery updates = %+v, want parent plus two mailboxes", client.updates)
+	}
+	seen := make(map[string]bdcli.UpdateInput, len(client.updates))
+	for _, update := range client.updates {
+		seen[update.issueID] = update.input
+	}
+	for _, issueID := range []string{"demo-parent", "demo-parent.1", "demo-parent.2"} {
+		input, ok := seen[issueID]
+		if !ok {
+			t.Fatalf("recovery did not reset %s: %+v", issueID, seen)
+		}
+		if input.Status != "open" || !input.ClearDefer {
+			t.Fatalf("recovery update for %s = %+v, want open and clear defer", issueID, input)
+		}
+		if input.Description != nil || len(input.AddLabels) != 0 {
+			t.Fatalf("recovery update for %s changed preserved text/labels: %+v", issueID, input)
+		}
+	}
+}
+
+type statusClient struct {
+	mailboxClient
+	issues       map[string]bdcli.Issue
+	shown        []string
+	updates      []updateCall
+	beforeUpdate func(string)
+}
+
+func newStatusClient(statuses map[string]string) *statusClient {
+	issues := make(map[string]bdcli.Issue, len(statuses))
+	for issueID, status := range statuses {
+		issues[issueID] = bdcli.Issue{ID: issueID, Status: status}
+	}
+	return &statusClient{issues: issues}
+}
+
+func (f *statusClient) Show(_ context.Context, issueID string) (bdcli.Issue, error) {
+	f.shown = append(f.shown, issueID)
+	issue, ok := f.issues[issueID]
+	if !ok {
+		return bdcli.Issue{}, errors.New("unknown issue " + issueID)
+	}
+	return issue, nil
+}
+
+func (f *statusClient) Update(_ context.Context, issueID string, input bdcli.UpdateInput) error {
+	f.updates = append(f.updates, updateCall{issueID: issueID, input: input})
+	if f.beforeUpdate != nil {
+		f.beforeUpdate(issueID)
+	}
+	issue := f.issues[issueID]
+	if input.Status != "" {
+		issue.Status = input.Status
+	}
+	f.issues[issueID] = issue
+	return nil
+}
+
+var _ bdcli.Client = (*statusClient)(nil)

package/internal/task/beads/testdata/strict-bd-repo.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+set -eu
+
+fail() {
+  printf 'unsupported or malformed bd invocation: %s\n' "$*" >&2
+  exit 64
+}
+
+[ -n "${BD_LOG-}" ] || fail "BD_LOG is missing"
+[ -n "${BEADS_DIR-}" ] || fail "BEADS_DIR is missing"
+[ "${BEADS_DB+x}" != x ] || fail "ambient BEADS_DB leaked"
+[ "${BD_DB+x}" != x ] || fail "ambient BD_DB leaked"
+printf '%s|%s|%s\n' "$PWD" "$BEADS_DIR" "$*" >> "$BD_LOG"
+
+if [ "$#" -eq 6 ] && [ "$1" = list ] && [ "$2" = --ready ] && [ "$3" = --limit ] && [ "$4" = 1 ] && [ "$5" = --no-parent ] && [ "$6" = --json ]; then
+  printf '[]\n'
+  exit 0
+fi
+if [ "$#" -eq 6 ] && [ "$1" = list ] && [ "$2" = --ready ] && [ "$3" = --no-parent ] && [ "$4" = --limit ] && [ "$5" = 0 ] && [ "$6" = --json ]; then
+  printf '[]\n'
+  exit 0
+fi
+if [ "$#" -eq 9 ] && [ "$1" = list ] && [ "$2" = --no-parent ] && [ "$3" = --status ] && [ "$4" = open,in_progress,blocked,deferred ] && [ "$5" = --label-pattern ] && [ "$6" = 'wf:*' ] && [ "$7" = --limit ] && [ "$8" = 0 ] && [ "$9" = --json ]; then
+  printf '[]\n'
+  exit 0
+fi
+fail "$@"

package/internal/task/beads/validation_test.go

@@ -0,0 +1,110 @@
+package beads
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+func validationSystem() *system {
+	return &system{base: config.Merge(DefaultConfig())}
+}
+
+func TestValidateConfigMergesWorkflowAndNodeValuesLocally(t *testing.T) {
+	err := validationSystem().ValidateConfig(context.Background(), config.RawValues{
+		"filters": map[string]any{
+			"parentStatuses": []any{"open"},
+			"labels":         []any{"backend"},
+		},
+	}, map[string]config.RawValues{
+		"implement": {"transitionTo": map[string]any{"taskStatus": "in_progress"}},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestValidateConfigRejectsUnknownNodeFields(t *testing.T) {
+	err := validationSystem().ValidateConfig(context.Background(), nil, map[string]config.RawValues{
+		"implement": {"unsupported": true},
+	})
+	if err == nil || !strings.Contains(err.Error(), "unsupported") {
+		t.Fatalf("unknown node field error = %v", err)
+	}
+}
+
+func TestValidateConfigRejectsNullAndInvalidFilterValues(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		raw  config.RawValues
+		want string
+	}{
+		{
+			name: "explicit null",
+			raw: config.RawValues{"filters": map[string]any{
+				"labels": nil,
+			}},
+			want: "explicit null",
+		},
+		{
+			name: "wrong filter type",
+			raw: config.RawValues{"filters": map[string]any{
+				"labels": "backend",
+			}},
+			want: "cannot unmarshal",
+		},
+		{
+			name: "empty filter value",
+			raw: config.RawValues{"filters": map[string]any{
+				"labels": []any{""},
+			}},
+			want: "must not be empty",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			err := validationSystem().ValidateConfig(context.Background(), tc.raw, nil)
+			if err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("validation error = %v, want %q", err, tc.want)
+			}
+		})
+	}
+}
+
+func TestValidateConfigRejectsUnsupportedStatusAndTemplate(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		raw  config.RawValues
+		want string
+	}{
+		{
+			name: "legacy status",
+			raw: config.RawValues{"status": map[string]any{
+				"mailbox": "in_review",
+			}},
+			want: "field status not found",
+		},
+		{
+			name: "summary placeholder",
+			raw: config.RawValues{"templates": map[string]any{
+				"summaryComment": "summary",
+			}},
+			want: "summaryComment must contain {{summaryReport}}",
+		},
+		{
+			name: "unknown template variable",
+			raw: config.RawValues{"templates": map[string]any{
+				"mailboxDescription": "mailbox {{unknown}}",
+			}},
+			want: "unknown template variable",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			err := validationSystem().ValidateConfig(context.Background(), tc.raw, nil)
+			if err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("validation error = %v, want %q", err, tc.want)
+			}
+		})
+	}
+}

package/internal/task/contract_test.go

@@ -24,6 +24,8 @@ type fakeSystem struct {
 	resets    []string
 }
 
+var _ task.System = (*fakeSystem)(nil)
+
 type storedTicket struct {
 	ticket    task.Ticket
 	isMailbox bool
@@ -65,6 +67,16 @@ func (f *fakeSystem) ValidateConfig(context.Context, config.RawValues, map[strin
 	return nil
 }
 
+func (f *fakeSystem) RenderText(_ task.TextKind, data task.TextData) (string, error) {
+	if data.SummaryReport != "" {
+		return data.SummaryReport, nil
+	}
+	if data.FeedbackReport != "" {
+		return data.FeedbackReport, nil
+	}
+	return data.NodeDescription, nil
+}
+
 func (f *fakeSystem) EnsureMailboxes(_ context.Context, _ task.TicketRef, _ string, specs []task.MailboxSpec) (map[string]task.Mailbox, error) {
 	for _, s := range specs {
 		if _, ok := f.mailboxes[s.Node]; !ok {

package/internal/task/factory.go

@@ -3,6 +3,7 @@ package task
 import (
 	"context"
 	"fmt"
+	"io"
 	"sort"
 	"strings"
 	"sync"
@@ -24,9 +25,12 @@ type RepoSpec struct {
 // canonical physical task scope (such as Jira site/project/component) used
 // to reject duplicate scope registration.
 type Factory struct {
-	RequiredRepoKeys func() []string
-	TaskScopeKey     func(rootConfig, repoConfig config.RawValues) (string, error)
-	New              func(context.Context, RepoSpec) (System, error)
+	RequiredRepoKeys   func() []string
+	TaskScopeKey       func(rootConfig, repoConfig config.RawValues) (string, error)
+	Auth               func(context.Context, []string, io.Reader) error
+	DefaultConfig      func() config.RawValues
+	ValidateTextConfig func(config.RawValues) error
+	New                func(context.Context, RepoSpec) (System, error)
 }
 
 var (
@@ -60,9 +64,54 @@ func New(ctx context.Context, name string, spec RepoSpec) (System, error) {
 	if err != nil {
 		return nil, err
 	}
+	spec.RootConfig = config.Merge(defaultConfig(f), spec.RootConfig)
 	return f.New(ctx, spec)
 }
 
+// Defaults returns a fresh copy of the selected task plugin's root config
+// defaults for relay-flow init.
+func Defaults(name string) (config.RawValues, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return nil, err
+	}
+	return config.Merge(defaultConfig(f)), nil
+}
+
+// ValidateTextConfig validates the selected task plugin's text templates
+// without requiring task-system credentials or a registered repo.
+func ValidateTextConfig(name string, cfg config.RawValues) error {
+	f, err := lookup(name)
+	if err != nil {
+		return err
+	}
+	if f.ValidateTextConfig == nil {
+		return nil
+	}
+	return f.ValidateTextConfig(config.Merge(defaultConfig(f), cfg))
+}
+
+func defaultConfig(f Factory) config.RawValues {
+	if f.DefaultConfig == nil {
+		return nil
+	}
+	return f.DefaultConfig()
+}
+
+// Auth dispatches system-wide authentication to the selected task plugin.
+// The plugin owns its flags, prompts, validation, credential format, and
+// credential storage.
+func Auth(ctx context.Context, name string, args []string, stdin io.Reader) error {
+	f, err := lookup(name)
+	if err != nil {
+		return err
+	}
+	if f.Auth == nil {
+		return fmt.Errorf("task: plugin %q does not support authentication", name)
+	}
+	return f.Auth(ctx, args, stdin)
+}
+
 // RequiredRepoKeys returns the repo YAML keys the named plugin requires at
 // registration.
 func RequiredRepoKeys(name string) ([]string, error) {