relay-flow 0.2.7-alpha → 0.2.8-alpha

package/internal/task/jira/status_defaults_test.go

@@ -0,0 +1,134 @@
+package jira
+
+import (
+	"context"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+func TestStatusRegistrationDefaultsOnlySelectAvailableConventions(t *testing.T) {
+	withConventions := statusRegistrationField("statusDefaults.start", "Start", []string{"Open", "In Progress", "Closed"}, defaultStartParentStatus)
+	if withConventions.Default != defaultStartParentStatus {
+		t.Fatalf("default = %q, want %q", withConventions.Default, defaultStartParentStatus)
+	}
+	withoutConventions := statusRegistrationField("statusDefaults.end", "End", []string{"Open", "Working", "Closed"}, defaultEndParentStatus)
+	if withoutConventions.Default != "" {
+		t.Fatalf("missing conventional default = %q, want empty", withoutConventions.Default)
+	}
+	if !reflect.DeepEqual(withoutConventions.Options, []string{"Open", "Working", "Closed"}) {
+		t.Fatalf("options = %v", withoutConventions.Options)
+	}
+}
+
+func TestRepositoryStatusDefaultsDriveLifecycleAndMailboxCompletion(t *testing.T) {
+	fake := &fakeJira{}
+	sys, err := newSystem(context.Background(), &fakeClient{fake: fake}, task.RepoSpec{
+		Name: "payments",
+		RepoConfig: config.RawValues{
+			"project":   "PAY",
+			"component": "api",
+			"statusDefaults": map[string]any{
+				"start": "Open",
+				"work":  "Working",
+				"end":   "Closed",
+			},
+		},
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defaults := task.LifecycleDefaults(sys)
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mailbox := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
+
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, defaults.StartDefaults()); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent, Mailbox: &mailbox}, defaults.WorkDefaults()); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.CompleteMailbox(context.Background(), mailbox); err != nil {
+		t.Fatal(err)
+	}
+	if len(fake.parentTransitions) != 1 || fake.parentTransitions[0] != "Open" {
+		t.Fatalf("parent transitions = %v, want [Open]", fake.parentTransitions)
+	}
+	if len(fake.taskTransitions) != 2 || fake.taskTransitions[0] != "Working" || fake.taskTransitions[1] != "Closed" {
+		t.Fatalf("mailbox transitions = %v, want [Working Closed]", fake.taskTransitions)
+	}
+}
+
+func TestJiraRegistrationRejectsComponentOverride(t *testing.T) {
+	err := validateJiraRegistration(context.Background(), task.RepoRegistrationSpec{
+		Name: "payments",
+		RepoConfig: config.RawValues{
+			"project":   "PAY",
+			"component": "other-component",
+			"statusDefaults": map[string]any{
+				"start": "Open", "work": "Working", "end": "Closed",
+			},
+		},
+	})
+	if err == nil || !strings.Contains(err.Error(), "must match repository name") {
+		t.Fatalf("component override error = %v", err)
+	}
+}
+
+func TestJiraConstructionRejectsRootStatusDefaults(t *testing.T) {
+	_, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
+		Name:       "payments",
+		RootConfig: config.RawValues{"statusDefaults": map[string]any{}},
+		RepoConfig: testRepoConfig(nil),
+	})
+	if err == nil || !strings.Contains(err.Error(), "configured per repository") {
+		t.Fatalf("root statusDefaults error = %v", err)
+	}
+}
+
+func TestJiraValidateConfigRejectsNonRepositoryStatusDefaults(t *testing.T) {
+	sys := newSystemWithFake(t, &fakeJira{})
+	for _, tc := range []struct {
+		name string
+		node bool
+	}{
+		{name: "workflow"},
+		{name: "node", node: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			workflowConfig := config.RawValues{}
+			nodeConfig := map[string]config.RawValues{}
+			if tc.node {
+				nodeConfig["coding"] = config.RawValues{"statusDefaults": map[string]any{}}
+			} else {
+				workflowConfig["statusDefaults"] = map[string]any{}
+			}
+			err := sys.ValidateConfig(context.Background(), workflowConfig, nodeConfig)
+			if err == nil || !strings.Contains(err.Error(), "configured per repository") {
+				t.Fatalf("validation error = %v", err)
+			}
+		})
+	}
+}
+
+func TestJiraConstructionRequiresCompleteRepositoryStatusDefaults(t *testing.T) {
+	for _, repoConfig := range []config.RawValues{
+		{"project": "PAY", "component": "api"},
+		{"project": "PAY", "component": "api", "statusDefaults": map[string]any{}},
+		{"project": "PAY", "component": "api", "statusDefaults": map[string]any{
+			"start": "Open", "work": "Working",
+		}},
+	} {
+		client := &validationClient{}
+		_, err := newSystem(context.Background(), client, task.RepoSpec{Name: "payments", RepoConfig: repoConfig})
+		if err == nil {
+			t.Fatalf("repo config %#v was accepted without complete status defaults", repoConfig)
+		}
+		if len(client.statuses) != 0 {
+			t.Fatalf("status probes = %v for invalid repository config, want none", client.statuses)
+		}
+	}
+}

package/internal/task/jira/templates_test.go

@@ -21,7 +21,7 @@ func TestTaskTextTemplatesExposeValues(t *testing.T) {
 			"summaryComment":     "summary {{sourceNode}}|{{targetNode}}|{{mailbox}}\n{{summaryReport}}",
 			"feedbackComment":    "feedback {{sourceNode}}|{{targetNode}}|{{mailbox}}\n{{feedbackReport}}",
 		}},
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		RepoConfig: testRepoConfig(nil),
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -91,7 +91,7 @@ func TestTaskTemplatesRenderSharedReportContractValues(t *testing.T) {
 	}
 	fixture := fixtures["work"]
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
-		Name: "payments", RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		Name: "payments", RepoConfig: testRepoConfig(nil),
 	})
 	if err != nil {
 		t.Fatal(err)

package/internal/task/jira/transition_defaults_test.go

@@ -10,11 +10,9 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/task"
 )
 
-// 3.5: Jira transition defaults per specs/workflow-definition "Jira
-// transition defaults are deterministic": omitted transitions default to
-// parent In Progress at start, mailbox In Progress at agent/HITL work
-// nodes, and parent Done at end; an omitted work-node parent transition
-// leaves the parent unchanged.
+// Jira repository status defaults are deterministic: omitted transitions use
+// the registered start/work/end values, and an omitted work-node parent
+// transition leaves the parent unchanged.
 //
 // This test is package-local (package jira) so it can drive the adapter's
 // ApplyTaskConfig against a test-local fake client without inventing an
@@ -128,10 +126,8 @@ func TestEndDefaultParentDone(t *testing.T) {
 	sys := newSystemWithFake(t, fake)
 	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
 
-	// end: omitted transitionTo. The end effective config carries no
-	// transition; the adapter must still default the parent to Done. Run
-	// orchestration merges EndDefaults under the end node config before
-	// applying it to the parent target.
+	// end: omitted transitionTo. Run orchestration merges the registered
+	// EndDefaults under the end node config before applying it to the parent.
 	endCfg := config.Merge(sys.(task.LifecycleDefaults).EndDefaults(), config.RawValues{})
 	if err := sys.ApplyTaskConfig(context.Background(), task.Target{Parent: parent}, endCfg); err != nil {
 		t.Fatalf("ApplyTaskConfig end failed: %v", err)
@@ -156,8 +152,8 @@ func TestPrepareRestartReopensMailboxesWithoutChangingParent(t *testing.T) {
 	if err := preparer.PrepareRestart(context.Background(), parent, mailboxes); err != nil {
 		t.Fatalf("PrepareRestart failed: %v", err)
 	}
-	if len(fake.taskTransitions) != 2 || fake.taskTransitions[0] != "To Do" || fake.taskTransitions[1] != "To Do" {
-		t.Fatalf("mailbox transitions = %v, want two To Do transitions", fake.taskTransitions)
+	if len(fake.taskTransitions) != 2 || fake.taskTransitions[0] != defaultStartParentStatus || fake.taskTransitions[1] != defaultStartParentStatus {
+		t.Fatalf("mailbox transitions = %v, want two %s transitions", fake.taskTransitions, defaultStartParentStatus)
 	}
 	if len(fake.parentTransitions) != 0 {
 		t.Fatalf("parent transitions = %v, want none (start owns parent status)", fake.parentTransitions)
@@ -165,7 +161,7 @@ func TestPrepareRestartReopensMailboxesWithoutChangingParent(t *testing.T) {
 }
 
 func TestPrepareRestartPreservesHumanJiraStateOnConflict(t *testing.T) {
-	fake := &fakeJira{transitionErr: errors.New(`transition to "To Do" is not available for PAY-102`)}
+	fake := &fakeJira{transitionErr: errors.New(`transition to "In Progress" is not available for PAY-102`)}
 	sys := newSystemWithFake(t, fake)
 	preparer := sys.(task.RestartPreparer)
 	err := preparer.PrepareRestart(context.Background(), task.TicketRef{Key: "PAY-101"}, []task.Mailbox{

package/internal/task/jira/validation_test.go

@@ -88,7 +88,9 @@ func TestValidateConfigProbesWorkflowAssignee(t *testing.T) {
 
 func taskSpec(root, repo config.RawValues) task.RepoSpec {
 	if repo == nil {
-		repo = config.RawValues{"project": "PAY", "component": "api"}
+		repo = testRepoConfig(nil)
+	} else {
+		repo = config.Merge(testRepoConfig(nil), repo)
 	}
 	return task.RepoSpec{Name: "payments", RootConfig: root, RepoConfig: repo}
 }

package/internal/task/registration.go

@@ -0,0 +1,59 @@
+package task
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// RegistrationField describes one task-plugin-owned repository-registration
+// value. The CLI only renders this metadata; it does not interpret provider
+// names or status vocabulary. A field with Options is rendered as a select,
+// otherwise it is rendered as free text. Derived fields are filled from the
+// runner candidate name and are never prompted.
+type RegistrationField struct {
+	Key     string   `json:"key"`
+	Title   string   `json:"title"`
+	Options []string `json:"options,omitempty"`
+	Default string   `json:"default,omitempty"`
+	Derived bool     `json:"derived,omitempty"`
+}
+
+// Registration describes the fields needed by a task plugin for one repo
+// registration.
+type Registration struct {
+	Fields []RegistrationField `json:"fields"`
+}
+
+// RegistrationFields returns task-plugin-owned registration metadata for the
+// supplied values. Values use the plugin's registration keys (including
+// dotted keys such as statusDefaults.start) and are intentionally opaque to
+// core.
+func RegistrationFields(ctx context.Context, name string, values config.RawValues) ([]RegistrationField, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return nil, err
+	}
+	if f.RegistrationFields == nil {
+		return nil, fmt.Errorf("task plugin %q does not provide repository registration fields", name)
+	}
+	return f.RegistrationFields(ctx, values)
+}
+
+// ValidateRegistration lets a task plugin validate registration values,
+// including remote project/workflow metadata, before the repository is
+// persisted. Plugins that do not need this phase remain unchanged.
+func ValidateRegistration(ctx context.Context, name string, spec RepoRegistrationSpec) error {
+	f, err := lookup(name)
+	if err != nil {
+		return err
+	}
+	if f.ValidateRegistration == nil {
+		return nil
+	}
+	if err := f.ValidateRegistration(ctx, spec); err != nil {
+		return fmt.Errorf("task registration: %w", err)
+	}
+	return nil
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-flow",
-  "version": "0.2.7-alpha",
+  "version": "0.2.8-alpha",
   "description": "Graph-based agent workflow engine — tracker-agnostic, pluggable runners",
   "bin": {
     "relay-flow": "./bin/relay-flow.js",