relay-flow 0.2.1-alpha → 0.2.2-alpha

package/internal/task/jira/jira.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"fmt"
 	"log/slog"
+	"regexp"
 	"sort"
 	"strings"
 	"sync"
@@ -23,6 +24,14 @@ type Config struct {
 	Component  string       `yaml:"component,omitempty"`
 	Filters    Filters      `yaml:"filters,omitempty"`
 	Transition TransitionTo `yaml:"transitionTo,omitempty"`
+	Templates  Templates    `yaml:"templates,omitempty"`
+}
+
+// Templates are Jira-owned task-system descriptions and comments.
+type Templates struct {
+	MailboxDescription string `yaml:"mailboxDescription"`
+	SummaryComment     string `yaml:"summaryComment"`
+	FeedbackComment    string `yaml:"feedbackComment"`
 }
 
 // Filters are the structured, locally evaluable workflow ticket matchers.
@@ -41,11 +50,47 @@ type TransitionTo struct {
 
 // Deterministic transition defaults for omitted values.
 const (
-	defaultStartParentStatus = "In Progress"
-	defaultWorkTaskStatus    = "In Progress"
-	defaultEndParentStatus   = "Done"
+	defaultStartParentStatus  = "In Progress"
+	defaultWorkTaskStatus     = "In Progress"
+	defaultEndParentStatus    = "Done"
+	defaultMailboxDescription = `Parent ticket: {{ticket}}
+Workflow: {{workflow}}
+Node: {{node}}
+Node type: {{nodeType}}
+Agent: {{agent}}
+Mailbox: {{mailbox}}
+
+Node work:
+{{nodeDescription}}
+
+Read this mailbox's comments for feedback from previous nodes.`
+	defaultSummaryComment = `Summary for {{node}}
+
+{{summaryReport}}`
+	defaultFeedbackComment = `Feedback from {{sourceNode}} to {{targetNode}} mailbox {{mailbox}}
+
+{{feedbackReport}}`
 )
 
+var textVarPattern = regexp.MustCompile(`\{\{([^{}]*)\}\}`)
+
+var knownTextVars = map[string]bool{
+	"runID": true, "ticket": true, "workflow": true,
+	"repo": true, "node": true, "nodeType": true, "agent": true,
+	"nodeDescription": true, "nextSteps": true, "successRoutes": true,
+	"failureRoutes": true, "mailbox": true, "sourceNode": true,
+	"targetNode": true, "summaryReport": true, "feedbackReport": true,
+}
+
+// DefaultConfig supplies Jira task-system text defaults for relay-flow init.
+func DefaultConfig() config.RawValues {
+	return config.RawValues{"templates": map[string]any{
+		"mailboxDescription": defaultMailboxDescription,
+		"summaryComment":     defaultSummaryComment,
+		"feedbackComment":    defaultFeedbackComment,
+	}}
+}
+
 var (
 	clientsMu sync.Mutex
 	clients   = map[string]struct {
@@ -60,6 +105,14 @@ func claimLabel(workflow string) string { return "wf:" + workflow }
 func init() {
 	task.Register("jira", task.Factory{
 		RequiredRepoKeys: func() []string { return []string{"project", "component"} },
+		DefaultConfig:    DefaultConfig,
+		ValidateTextConfig: func(raw config.RawValues) error {
+			var cfg Config
+			if err := config.DecodeStrict(raw, &cfg); err != nil {
+				return err
+			}
+			return validateTemplates(cfg.Templates)
+		},
 		TaskScopeKey: func(rootConfig, repoConfig config.RawValues) (string, error) {
 			var root, repoCfg Config
 			if err := config.DecodeStrict(rootConfig, &root); err != nil {
@@ -130,11 +183,14 @@ func newSystem(ctx context.Context, cli jirarest.Client, spec task.RepoSpec) (*s
 	if spec.Name == "" {
 		return nil, fmt.Errorf("jira: repo name is required")
 	}
-	merged := config.Merge(spec.RootConfig, spec.RepoConfig)
+	merged := config.Merge(DefaultConfig(), spec.RootConfig, spec.RepoConfig)
 	var cfg Config
 	if err := config.DecodeStrict(merged, &cfg); err != nil {
 		return nil, fmt.Errorf("jira repo %q config: %w", spec.Name, err)
 	}
+	if err := validateTemplates(cfg.Templates); err != nil {
+		return nil, fmt.Errorf("jira repo %q taskConfig.templates: %w", spec.Name, err)
+	}
 	if cfg.Assignee != "" {
 		if err := cli.ValidateAssignee(ctx, cfg.Project, cfg.Assignee); err != nil {
 			return nil, fmt.Errorf("jira repo %q assignee %q: %w", spec.Name, cfg.Assignee, err)
@@ -171,6 +227,55 @@ func decodeConfig(raw config.RawValues) (Config, error) {
 	return cfg, nil
 }
 
+func validateTemplates(templates Templates) error {
+	for name, tmpl := range map[string]string{
+		"mailboxDescription": templates.MailboxDescription,
+		"summaryComment":     templates.SummaryComment,
+		"feedbackComment":    templates.FeedbackComment,
+	} {
+		for _, match := range textVarPattern.FindAllStringSubmatch(tmpl, -1) {
+			if !knownTextVars[match[1]] {
+				return fmt.Errorf("%s: unknown template variable {{%s}}", name, match[1])
+			}
+		}
+	}
+	if !strings.Contains(templates.SummaryComment, "{{summaryReport}}") {
+		return fmt.Errorf("summaryComment must contain {{summaryReport}}")
+	}
+	if !strings.Contains(templates.FeedbackComment, "{{feedbackReport}}") {
+		return fmt.Errorf("feedbackComment must contain {{feedbackReport}}")
+	}
+	return nil
+}
+
+// RenderText renders Jira-owned mailbox descriptions and comments.
+func (s *system) RenderText(kind task.TextKind, data task.TextData) (string, error) {
+	var tmpl string
+	switch kind {
+	case task.TextMailboxDescription:
+		tmpl = s.effective.Templates.MailboxDescription
+	case task.TextSummaryComment:
+		tmpl = s.effective.Templates.SummaryComment
+	case task.TextFeedbackComment:
+		tmpl = s.effective.Templates.FeedbackComment
+	default:
+		return "", fmt.Errorf("jira: unknown task text kind %q", kind)
+	}
+	values := map[string]string{
+		"runID": data.RunID, "ticket": data.Ticket,
+		"workflow": data.Workflow, "repo": data.Repo, "node": data.Node,
+		"nodeType": data.NodeType, "agent": data.Agent,
+		"nodeDescription": data.NodeDescription, "nextSteps": data.NextSteps,
+		"successRoutes": data.SuccessRoutes, "failureRoutes": data.FailureRoutes,
+		"mailbox": data.Mailbox, "sourceNode": data.SourceNode,
+		"targetNode": data.TargetNode, "summaryReport": data.SummaryReport,
+		"feedbackReport": data.FeedbackReport,
+	}
+	return textVarPattern.ReplaceAllStringFunc(tmpl, func(match string) string {
+		return values[textVarPattern.FindStringSubmatch(match)[1]]
+	}), nil
+}
+
 // --- Poll / filters ---
 
 // buildJQL scopes the parent poll by project/component and active statuses.
@@ -212,11 +317,15 @@ func (s *system) Poll(ctx context.Context) ([]task.Ticket, error) {
 // CompileFilter compiles workflow taskConfig.filters into an in-memory
 // matcher over normalized ticket fields. Unknown filter fields are rejected.
 func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.Ticket) bool, error) {
-	cfg, err := decodeConfig(workflowTaskConfig)
+	merged := config.Merge(s.base, workflowTaskConfig)
+	cfg, err := decodeConfig(merged)
 	if err != nil {
 		return nil, err
 	}
 	f := cfg.Filters
+	if !hasAssigneeFilter(merged) && cfg.Assignee != "" {
+		f.Assignees = []string{cfg.Assignee}
+	}
 	return func(t task.Ticket) bool {
 		if len(f.ParentStatuses) > 0 && !contains(f.ParentStatuses, strField(t.Fields, "status")) {
 			return false
@@ -232,13 +341,26 @@ func (s *system) CompileFilter(workflowTaskConfig config.RawValues) (func(task.T
 				}
 			}
 		}
-		if len(f.Assignees) > 0 && !contains(f.Assignees, strField(t.Fields, "assignee")) {
+		if len(f.Assignees) > 0 && !containsFold(f.Assignees, strField(t.Fields, "assignee")) {
 			return false
 		}
 		return true
 	}, nil
 }
 
+func hasAssigneeFilter(raw config.RawValues) bool {
+	switch filters := raw["filters"].(type) {
+	case map[string]any:
+		_, ok := filters["assignees"]
+		return ok
+	case config.RawValues:
+		_, ok := filters["assignees"]
+		return ok
+	default:
+		return false
+	}
+}
+
 // --- Claim ---
 
 // Claim adds wf:<workflow> using the claims already inspected by routing.
@@ -257,6 +379,9 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 	if err != nil {
 		return fmt.Errorf("workflow taskConfig: %w", err)
 	}
+	if err := validateTemplates(workflowCfg.Templates); err != nil {
+		return fmt.Errorf("workflow taskConfig.templates: %w", err)
+	}
 	if err := s.validateAssignee(ctx, "workflow", workflowCfg.Project, workflowCfg.Assignee); err != nil {
 		return err
 	}
@@ -273,6 +398,9 @@ func (s *system) ValidateConfig(ctx context.Context, workflowTaskConfig config.R
 		if err != nil {
 			return fmt.Errorf("node %q taskConfig: %w", n, err)
 		}
+		if err := validateTemplates(cfg.Templates); err != nil {
+			return fmt.Errorf("node %q taskConfig.templates: %w", n, err)
+		}
 		if err := s.validateAssignee(ctx, fmt.Sprintf("node %q", n), cfg.Project, cfg.Assignee); err != nil {
 			return err
 		}
@@ -315,47 +443,47 @@ func (s *system) validateTransition(ctx context.Context, scope, project string,
 // LifecycleDefaults exposure: the deterministic Jira transition defaults per
 // lifecycle point (spec: Jira transition defaults are deterministic). Run
 // orchestration merges these raw values under the effective node config
-// before ApplyTaskConfig; omitted values inherit the default, explicit
-// values win (map merge with defaults as the lower layer).
+// before ApplyTaskConfig, so the effective precedence is
+// built-in default < root < repo < workflow < node.
+//
+// The methods also carry the inherited root/repository transitionTo and
+// assignee values. ApplyTaskConfig receives only the workflow/node config the
+// caller assembles, so returning inherited values here is what makes a
+// repo-scoped value take effect at runtime instead of being validated and then
+// silently discarded. internal/task/beads implements the same rule; keep the
+// two adapters aligned.
 
 // StartDefaults defaults the parent to In Progress.
 func (s *system) StartDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"parentStatus": defaultStartParentStatus}}
+	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultStartParentStatus))
 }
 
 // WorkDefaults defaults the mailbox task status to In Progress; the parent
 // is left unchanged when parentStatus is omitted.
 func (s *system) WorkDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"taskStatus": defaultWorkTaskStatus}}
+	return s.lifecycleDefaults(transitionDefault("taskStatus", defaultWorkTaskStatus))
 }
 
 // EndDefaults defaults the parent to Done.
 func (s *system) EndDefaults() config.RawValues {
-	return config.RawValues{"transitionTo": map[string]any{"parentStatus": defaultEndParentStatus}}
+	return s.lifecycleDefaults(transitionDefault("parentStatus", defaultEndParentStatus))
 }
 
-// endConfig applies the deterministic end default: omitted parentStatus
-// becomes Done.
-func endConfig(cfg config.RawValues) config.RawValues {
-	return withTransitionDefault(cfg, "parentStatus", defaultEndParentStatus)
+func transitionDefault(key, value string) config.RawValues {
+	return config.RawValues{"transitionTo": map[string]any{key: value}}
 }
 
-func withTransitionDefault(cfg config.RawValues, key, value string) config.RawValues {
-	out := config.RawValues{}
-	for k, v := range cfg {
-		out[k] = v
-	}
-	merged := map[string]any{}
-	if tr, ok := out["transitionTo"].(map[string]any); ok {
-		for k, v := range tr {
-			merged[k] = v
+// lifecycleDefaults layers the inherited root/repository operation values over
+// the built-in lifecycle default. Only the keys ApplyTaskConfig consumes are
+// carried, so unrelated configuration never enters durable activity inputs.
+func (s *system) lifecycleDefaults(builtin config.RawValues) config.RawValues {
+	inherited := config.RawValues{}
+	for _, key := range []string{"transitionTo", "assignee"} {
+		if value, ok := s.base[key]; ok {
+			inherited[key] = value
 		}
 	}
-	if _, ok := merged[key]; !ok {
-		merged[key] = value
-	}
-	out["transitionTo"] = merged
-	return out
+	return config.Merge(builtin, inherited)
 }
 
 // --- Mailboxes ---
@@ -527,6 +655,15 @@ func contains(xs []string, want string) bool {
 	return false
 }
 
+func containsFold(xs []string, want string) bool {
+	for _, x := range xs {
+		if strings.EqualFold(x, want) {
+			return true
+		}
+	}
+	return false
+}
+
 func strField(fields map[string]any, key string) string {
 	s, _ := fields[key].(string)
 	return s
@@ -536,3 +673,8 @@ func strSliceField(fields map[string]any, key string) []string {
 	out, _ := fields[key].([]string)
 	return out
 }
+
+var (
+	_ task.System            = (*system)(nil)
+	_ task.LifecycleDefaults = (*system)(nil)
+)

package/internal/task/jira/lifecycle_inheritance_test.go

@@ -0,0 +1,172 @@
+package jira
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+// 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 against the live task system, 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/beads/lifecycle_inheritance_test.go is the sibling of this
+// file and asserts the same invariants against the Beads 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(t *testing.T, fake *fakeJira, repoValues config.RawValues) task.System {
+	t.Helper()
+	repoConfig := config.Merge(config.RawValues{"project": "PAY", "component": "api"}, repoValues)
+	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
+		Name:       "payments",
+		RepoConfig: repoConfig,
+	})
+	if err != nil {
+		t.Fatalf("adapter construction failed: %v", err)
+	}
+	return sys
+}
+
+// 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) {
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	t.Run("repo parentStatus reaches start", func(t *testing.T) {
+		fake := &fakeJira{}
+		sys := repoScopedSystem(t, fake, config.RawValues{
+			"transitionTo": map[string]any{"parentStatus": "In Review"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).StartDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "In Review" {
+			t.Fatalf("parent transitions = %v, want the inherited repo value to beat the built-in default",
+				fake.parentTransitions)
+		}
+	})
+
+	t.Run("repo taskStatus reaches a work node", func(t *testing.T) {
+		fake := &fakeJira{}
+		sys := repoScopedSystem(t, fake, config.RawValues{
+			"transitionTo": map[string]any{"taskStatus": "In Review"},
+		})
+		cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+		if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+			t.Fatal(err)
+		}
+		if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != "In Review" {
+			t.Fatalf("mailbox transitions = %v, want the inherited repo value to beat the built-in default",
+				fake.taskTransitions)
+		}
+	})
+}
+
+func TestLifecycleDefaultsCarryInheritedAssignee(t *testing.T) {
+	fake := &fakeJira{}
+	sys := repoScopedSystem(t, fake, config.RawValues{"assignee": "repo-bot@example.com"})
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+	cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), nil, nil)
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.assignments) != 1 || fake.assignments[0] != "PAY-102:repo-bot@example.com" {
+		t.Fatalf("assignments = %v, want the inherited repo assignee applied to the mailbox", fake.assignments)
+	}
+}
+
+func TestLifecycleDefaultsPrecedenceDefaultRepoWorkflowNode(t *testing.T) {
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	for _, tc := range []struct {
+		name     string
+		workflow config.RawValues
+		node     config.RawValues
+		want     string
+	}{
+		{name: "repo beats built-in default", want: "Repo Status"},
+		{
+			name:     "workflow beats repo",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "Workflow Status"}},
+			want:     "Workflow Status",
+		},
+		{
+			name:     "node beats workflow",
+			workflow: config.RawValues{"transitionTo": map[string]any{"taskStatus": "Workflow Status"}},
+			node:     config.RawValues{"transitionTo": map[string]any{"taskStatus": "Node Status"}},
+			want:     "Node Status",
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			fake := &fakeJira{}
+			sys := repoScopedSystem(t, fake, config.RawValues{
+				"transitionTo": map[string]any{"taskStatus": "Repo Status"},
+			})
+			cfg := operationConfig(lifecycleDefaultsOf(t, sys).WorkDefaults(), tc.workflow, tc.node)
+
+			if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, cfg); err != nil {
+				t.Fatal(err)
+			}
+			if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != tc.want {
+				t.Fatalf("mailbox transitions = %v, want [%s]", fake.taskTransitions, tc.want)
+			}
+		})
+	}
+}
+
+// With nothing inherited, the built-in lifecycle values still apply.
+func TestLifecycleDefaultsWithoutInheritedValues(t *testing.T) {
+	fake := &fakeJira{}
+	sys := repoScopedSystem(t, fake, nil)
+	d := lifecycleDefaultsOf(t, sys)
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := &task.Mailbox{ID: "2", Key: "PAY-102", Node: "implement"}
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, operationConfig(d.StartDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: mailbox}, operationConfig(d.WorkDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, operationConfig(d.EndDefaults(), nil, nil)); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.parentTransitions) != 2 || fake.parentTransitions[0] != defaultStartParentStatus || fake.parentTransitions[1] != defaultEndParentStatus {
+		t.Fatalf("parent transitions = %v, want [%s %s]", fake.parentTransitions, defaultStartParentStatus, defaultEndParentStatus)
+	}
+	if len(fake.taskTransitions) != 1 || fake.taskTransitions[0] != defaultWorkTaskStatus {
+		t.Fatalf("mailbox transitions = %v, want [%s]", fake.taskTransitions, defaultWorkTaskStatus)
+	}
+	if len(fake.assignments) != 0 {
+		t.Fatalf("assignments = %v, want none when no assignee is configured", fake.assignments)
+	}
+}