relay-flow 0.2.7-alpha → 0.2.8-alpha

package/internal/repo/service_test.go

@@ -264,7 +264,10 @@ func (errInvalidRepo) Error() string { return "invalid repo" }
 
 func TestRegisterAtomicallyPersists(t *testing.T) {
 	fx := newServiceFixture(t, &fakeRunnerDiscovery{})
-	if _, err := fx.svc.Register(context.Background(), repo.RegisterInput{Name: "payments", Path: "/srv/payments", TaskConfig: config.RawValues{"project": "PAY", "component": "api"}}); err != nil {
+	statusDefaults := map[string]any{"start": "Open", "work": "Working", "end": "Closed"}
+	if _, err := fx.svc.Register(context.Background(), repo.RegisterInput{Name: "payments", Path: "/srv/payments", TaskConfig: config.RawValues{
+		"project": "PAY", "component": "api", "statusDefaults": statusDefaults,
+	}}); err != nil {
 		t.Fatal(err)
 	}
 	cfg, err := config.LoadMachine(fx.cfgPath)
@@ -278,6 +281,16 @@ func TestRegisterAtomicallyPersists(t *testing.T) {
 	if r.TaskConfig["project"] != "PAY" {
 		t.Fatalf("repo taskConfig not persisted: %+v", r.TaskConfig)
 	}
+	var gotDefaults map[string]any
+	switch values := r.TaskConfig["statusDefaults"].(type) {
+	case map[string]any:
+		gotDefaults = values
+	case config.RawValues:
+		gotDefaults = map[string]any(values)
+	}
+	if gotDefaults == nil || gotDefaults["start"] != "Open" || gotDefaults["work"] != "Working" || gotDefaults["end"] != "Closed" {
+		t.Fatalf("repo statusDefaults not persisted: %#v", r.TaskConfig["statusDefaults"])
+	}
 }
 
 func TestRegisterSetsUpHarnessRepo(t *testing.T) {

package/internal/server/api_test.go

@@ -2,15 +2,19 @@ package server_test
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
+	"path/filepath"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/server"
 	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
@@ -287,6 +291,48 @@ func TestRunEndpointsExposeRetryDetails(t *testing.T) {
 	}
 }
 
+func TestRepoTaskFieldsSupportsInitialGetAndDependentPost(t *testing.T) {
+	fake := &fakeServices{}
+	c, cleanup := startHandler(t, fake)
+	defer cleanup()
+
+	code, env := do(t, c, http.MethodGet, "http://relay/repos/task-fields", nil)
+	if code != http.StatusOK || !env.OK || !bytes.Contains(env.Data, []byte(`"fields"`)) {
+		t.Fatalf("GET /repos/task-fields: code=%d env=%+v", code, env)
+	}
+	code, env = do(t, c, http.MethodPost, "http://relay/repos/task-fields", []byte(`{"values":{"project":"PAY"}}`))
+	if code != http.StatusOK || !env.OK || len(fake.registrationValues) != 2 {
+		t.Fatalf("POST /repos/task-fields: code=%d env=%+v values=%v", code, env, fake.registrationValues)
+	}
+	if fake.registrationValues[1]["project"] != "PAY" {
+		t.Fatalf("dependent registration values = %#v", fake.registrationValues[1])
+	}
+}
+
+func TestClientRepoRegistrationFieldsUsesGetThenPost(t *testing.T) {
+	fake := &fakeServices{}
+	dir := t.TempDir()
+	_, cleanup := startHandlerOnSocket(t, dir, fake)
+	defer cleanup()
+	client := server.NewClient(filepath.Join(dir, "server.sock"))
+	keys, err := client.RepoTaskFields(context.Background())
+	if err != nil || len(keys) != 2 || keys[0] != "project" || keys[1] != "component" {
+		t.Fatalf("documented task fields = %v, err=%v", keys, err)
+	}
+
+	initial, err := client.RepoRegistrationFields(context.Background(), nil)
+	if err != nil || len(initial.Fields) != 2 {
+		t.Fatalf("initial registration fields = %#v, err=%v", initial, err)
+	}
+	dependent, err := client.RepoRegistrationFields(context.Background(), config.RawValues{"project": "PAY"})
+	if err != nil || len(dependent.Fields) != 2 {
+		t.Fatalf("dependent registration fields = %#v, err=%v", dependent, err)
+	}
+	if len(fake.registrationValues) != 3 || fake.registrationValues[0] != nil || fake.registrationValues[1] != nil || fake.registrationValues[2]["project"] != "PAY" {
+		t.Fatalf("registration request values = %#v", fake.registrationValues)
+	}
+}
+
 func TestRepoOperations(t *testing.T) {
 	c, cleanup := startHandler(t, &fakeServices{})
 	defer cleanup()

package/internal/server/client.go

@@ -10,9 +10,11 @@ import (
 	"net/http"
 	"net/url"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
 	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
@@ -134,8 +136,7 @@ func (c *Client) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, err
 	return out, nil
 }
 
-// RepoTaskFields returns the task factory's required repo keys, matching
-// GET /repos/task-fields (server wraps the list as {"fields": [...]}).
+// RepoTaskFields returns the documented initial required-key metadata.
 func (c *Client) RepoTaskFields(ctx context.Context) ([]string, error) {
 	var out struct {
 		Fields []string `json:"fields"`
@@ -146,6 +147,33 @@ func (c *Client) RepoTaskFields(ctx context.Context) ([]string, error) {
 	return out.Fields, nil
 }
 
+// RepoRegistrationFields returns task-plugin-owned repository prompts. Values
+// are flat registration inputs so plugins can discover dependent choices (for
+// example project statuses after project is selected). Initial discovery uses
+// the documented GET endpoint; dependent discovery uses POST.
+func (c *Client) RepoRegistrationFields(ctx context.Context, values config.RawValues) (task.Registration, error) {
+	if len(values) == 0 {
+		var out struct {
+			Registration task.Registration `json:"registration"`
+		}
+		if err := c.call(ctx, http.MethodGet, "/repos/task-fields", nil, &out); err != nil {
+			return task.Registration{}, err
+		}
+		return out.Registration, nil
+	}
+	payload, err := json.Marshal(struct {
+		Values config.RawValues `json:"values,omitempty"`
+	}{Values: values})
+	if err != nil {
+		return task.Registration{}, err
+	}
+	var out task.Registration
+	if err := c.call(ctx, http.MethodPost, "/repos/task-fields", payload, &out); err != nil {
+		return task.Registration{}, err
+	}
+	return out, nil
+}
+
 // RegisterRepo registers a repo by name/path with optional task config.
 func (c *Client) RegisterRepo(ctx context.Context, input repo.RegisterInput) (repo.Info, error) {
 	payload, _ := json.Marshal(input)

package/internal/server/fixture_test.go

@@ -12,10 +12,12 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
 	"github.com/rajpopat27/relay-flow/internal/runner"
 	"github.com/rajpopat27/relay-flow/internal/server"
+	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
@@ -23,20 +25,21 @@ import (
 // seams. activeWorkflows seeds workflows with an active run (drives 409);
 // failRepos forces a 500; slowReport simulates a long-running report call.
 type fakeServices struct {
-	activeWorkflows  map[string]bool
-	failRepos        bool
-	slowReport       chan struct{}
-	workflows        map[string]*workflow.Workflow
-	repos            map[string]repo.Info
-	runs             []run.Run
-	shutdownCh       chan struct{}
-	registrations    []run.NodeRuntimeRegistration
-	runtimeAck       run.NodeRuntimeRegistrationAck
-	processedReports map[string]bool
-	submittedReports int
-	restartRun       run.Run
-	restartErr       error
-	restarts         []string
+	activeWorkflows    map[string]bool
+	failRepos          bool
+	slowReport         chan struct{}
+	workflows          map[string]*workflow.Workflow
+	repos              map[string]repo.Info
+	runs               []run.Run
+	shutdownCh         chan struct{}
+	registrations      []run.NodeRuntimeRegistration
+	runtimeAck         run.NodeRuntimeRegistrationAck
+	processedReports   map[string]bool
+	submittedReports   int
+	restartRun         run.Run
+	restartErr         error
+	restarts           []string
+	registrationValues []config.RawValues
 }
 
 func (f *fakeServices) SubmitWorkflow(_ context.Context, yaml []byte) (*workflow.Workflow, error) {
@@ -152,8 +155,9 @@ func (f *fakeServices) DiscoverRepos(context.Context) ([]runner.RepoCandidate, e
 	return []runner.RepoCandidate{{Name: "payments", Path: "/srv/payments"}}, nil
 }
 
-func (f *fakeServices) TaskFields(context.Context) ([]string, error) {
-	return []string{"status", "labels"}, nil
+func (f *fakeServices) TaskRegistrationFields(_ context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	f.registrationValues = append(f.registrationValues, values)
+	return []task.RegistrationField{{Key: "project", Title: "Project"}, {Key: "component", Title: "Component", Derived: true}}, nil
 }
 
 func (f *fakeServices) RegisterRepo(_ context.Context, input repo.RegisterInput) (repo.Info, error) {

package/internal/server/server.go

@@ -12,9 +12,11 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/repo"
 	"github.com/rajpopat27/relay-flow/internal/run"
 	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
@@ -41,7 +43,7 @@ type Deps interface {
 
 	// Repos
 	DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, error)
-	TaskFields(ctx context.Context) ([]string, error)
+	TaskRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error)
 	RegisterRepo(ctx context.Context, input repo.RegisterInput) (repo.Info, error)
 	ListRepos(ctx context.Context) ([]repo.Info, error)
 	GetRepo(ctx context.Context, name string) (repo.Info, error)
@@ -246,15 +248,48 @@ func (s *server) handleReposDiscover(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *server) handleRepoTaskFields(w http.ResponseWriter, r *http.Request) {
-	if !methodOnly(w, r, http.MethodGet) {
+	if r.Method == http.MethodGet {
+		fields, err := s.deps.TaskRegistrationFields(r.Context(), nil)
+		if err != nil {
+			mapErr(w, err)
+			return
+		}
+		keys := make([]string, 0, len(fields))
+		for _, field := range fields {
+			keys = append(keys, field.Key)
+		}
+		// Keep the documented fields list for callers that only need the
+		// required keys, and include plugin-owned metadata for the CLI's
+		// initial prompt construction.
+		writeOK(w, http.StatusOK, map[string]any{
+			"fields":       keys,
+			"registration": task.Registration{Fields: fields},
+		})
+		return
+	}
+	if !methodOnly(w, r, http.MethodPost) {
+		return
+	}
+	body, err := readBody(r)
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "invalid", err.Error())
 		return
 	}
-	fields, err := s.deps.TaskFields(r.Context())
+	var payload struct {
+		Values config.RawValues `json:"values,omitempty"`
+	}
+	if len(strings.TrimSpace(string(body))) > 0 {
+		if err := decodeStrict(body, &payload); err != nil {
+			writeErr(w, http.StatusBadRequest, "invalid", err.Error())
+			return
+		}
+	}
+	fields, err := s.deps.TaskRegistrationFields(r.Context(), payload.Values)
 	if err != nil {
 		mapErr(w, err)
 		return
 	}
-	writeOK(w, http.StatusOK, map[string]any{"fields": fields})
+	writeOK(w, http.StatusOK, task.Registration{Fields: fields})
 }
 
 func (s *server) handleRepos(w http.ResponseWriter, r *http.Request) {

package/internal/task/beads/beads.go

@@ -81,10 +81,15 @@ func DefaultConfig() config.RawValues {
 	}}
 }
 
+func registrationFields(context.Context, config.RawValues) ([]task.RegistrationField, error) {
+	return []task.RegistrationField{{Key: "beadsDir", Title: "Beads workspace"}}, nil
+}
+
 func init() {
 	task.Register("beads", task.Factory{
-		RequiredRepoKeys: func() []string { return []string{"beadsDir"} },
-		TaskScopeKey:     beadsTaskScopeKey,
+		RequiredRepoKeys:   func() []string { return []string{"beadsDir"} },
+		RegistrationFields: registrationFields,
+		TaskScopeKey:       beadsTaskScopeKey,
 		RegistrationKey: func(spec task.RepoRegistrationSpec) (string, error) {
 			label, err := RepositoryLabel(spec.Name)
 			if err != nil {

package/internal/task/beads/beads_test.go

@@ -29,6 +29,19 @@ func TestBeadsFactoryIsRegisteredWithBeadsDirRequirement(t *testing.T) {
 	}
 }
 
+func TestBeadsRegistrationDoesNotExposeJiraStatusFields(t *testing.T) {
+	fields, err := task.RegistrationFields(context.Background(), "beads", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(fields) != 1 || fields[0].Key != "beadsDir" {
+		t.Fatalf("registration fields = %#v, want only beadsDir", fields)
+	}
+	if len(fields[0].Options) != 0 || fields[0].Default != "" {
+		t.Fatalf("Beads registration field unexpectedly has status choices: %#v", fields[0])
+	}
+}
+
 func TestBeadsConfigRejectsUnknownFields(t *testing.T) {
 	for _, field := range []string{"unknownField", "project", "component"} {
 		t.Run(field, func(t *testing.T) {

package/internal/task/factory.go

@@ -36,13 +36,15 @@ type RepoRegistrationSpec struct {
 // the complete registration identity when a plugin permits sharing a
 // physical scope with distinct logical repositories.
 type Factory struct {
-	RequiredRepoKeys   func() []string
-	TaskScopeKey       func(rootConfig, repoConfig config.RawValues) (string, error)
-	RegistrationKey    func(RepoRegistrationSpec) (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)
+	RequiredRepoKeys     func() []string
+	TaskScopeKey         func(rootConfig, repoConfig config.RawValues) (string, error)
+	RegistrationKey      func(RepoRegistrationSpec) (string, error)
+	RegistrationFields   func(context.Context, config.RawValues) ([]RegistrationField, error)
+	ValidateRegistration func(context.Context, RepoRegistrationSpec) 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 (

package/internal/task/jira/auth_test.go

@@ -75,7 +75,15 @@ func TestAuthWritesLoadsAndNewUsesJiraOwnedCredentials(t *testing.T) {
 	}
 	if _, err := task.New(context.Background(), "jira", task.RepoSpec{
 		Name: "payments", RootConfig: machine.TaskConfig,
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		RepoConfig: config.RawValues{
+			"project":   "PAY",
+			"component": "api",
+			"statusDefaults": map[string]any{
+				"start": defaultStartParentStatus,
+				"work":  defaultWorkTaskStatus,
+				"end":   defaultEndParentStatus,
+			},
+		},
 	}); err != nil {
 		t.Fatalf("task.New did not load Jira-owned credentials: %v", err)
 	}

package/internal/task/jira/filters_test.go

@@ -284,7 +284,7 @@ func TestCompileFilterDoesNotUseEffectiveAssigneeAsFilter(t *testing.T) {
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
 		Name:       "payments",
 		RootConfig: config.RawValues{"assignee": "root@example.com"},
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api", "assignee": "Repo.Bot@Example.com"},
+		RepoConfig: testRepoConfig(config.RawValues{"assignee": "Repo.Bot@Example.com"}),
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -304,7 +304,7 @@ func TestCompileFilterWorkflowAssigneesOverrideEffectiveAssignee(t *testing.T) {
 	sys, err := newSystem(context.Background(), &fakeClient{fake: &fakeJira{}}, task.RepoSpec{
 		Name:       "payments",
 		RootConfig: config.RawValues{"assignee": "root@example.com"},
-		RepoConfig: config.RawValues{"project": "PAY", "component": "api"},
+		RepoConfig: testRepoConfig(nil),
 	})
 	if err != nil {
 		t.Fatal(err)

package/internal/task/jira/helpers_test.go

@@ -3,6 +3,7 @@ package jira
 import (
 	"context"
 
+	"github.com/rajpopat27/relay-flow/internal/config"
 	"github.com/rajpopat27/relay-flow/internal/task"
 	"github.com/rajpopat27/relay-flow/internal/task/jira/rest"
 )
@@ -67,6 +68,18 @@ func (notFakedError) Error() string { return "not faked" }
 
 var errNotFaked = notFakedError{}
 
+func testStatusDefaults() config.RawValues {
+	return config.RawValues{"statusDefaults": map[string]any{
+		"start": defaultStartParentStatus,
+		"work":  defaultWorkTaskStatus,
+		"end":   defaultEndParentStatus,
+	}}
+}
+
+func testRepoConfig(values config.RawValues) config.RawValues {
+	return config.Merge(config.RawValues{"project": "PAY", "component": "api"}, testStatusDefaults(), values)
+}
+
 // newSystemForTest builds the adapter around the test-local REST seam.
 func newSystemForTest(fake *fakeJira) (task.System, error) {
 	return newSystemForCLI(&fakeClient{fake: fake})