relay-flow 0.2.6-alpha → 0.2.8-alpha

package/cmd/relay-flow/repo_registration.go

@@ -0,0 +1,235 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/charmbracelet/huh"
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/repo"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+	"github.com/rajpopat27/relay-flow/internal/server"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+// loadRepoRegistration asks the selected task plugin for the fields needed by
+// registration. A second pass lets a plugin expose dependent choices after a
+// value such as a project has been supplied.
+func loadRepoRegistration(ctx context.Context, c *server.Client, supplied kvFlags) (task.Registration, error) {
+	initial, err := c.RepoRegistrationFields(ctx, nil)
+	if err != nil {
+		return task.Registration{}, err
+	}
+	if len(supplied) == 0 {
+		return initial, nil
+	}
+	dependent, err := c.RepoRegistrationFields(ctx, flatRegistrationValues(supplied))
+	if err != nil {
+		return task.Registration{}, err
+	}
+	return mergeRegistration(initial, dependent), nil
+}
+
+func flatRegistrationValues(values kvFlags) config.RawValues {
+	out := make(config.RawValues, len(values))
+	for key, value := range values {
+		out[key] = value
+	}
+	return out
+}
+
+func mergeRegistration(first, second task.Registration) task.Registration {
+	fields := make([]task.RegistrationField, 0, len(first.Fields)+len(second.Fields))
+	positions := map[string]int{}
+	for _, field := range append(append([]task.RegistrationField(nil), first.Fields...), second.Fields...) {
+		if index, ok := positions[field.Key]; ok {
+			fields[index] = field
+			continue
+		}
+		positions[field.Key] = len(fields)
+		fields = append(fields, field)
+	}
+	return task.Registration{Fields: fields}
+}
+
+// promptRepoRegistration renders only metadata returned by the task plugin.
+// The core CLI does not know which values are Jira statuses or how they are
+// validated.
+func promptRepoRegistration(reg task.Registration, values kvFlags) error {
+	for _, field := range reg.Fields {
+		if field.Derived || values[field.Key] != "" {
+			continue
+		}
+		title := field.Title
+		if title == "" {
+			title = field.Key
+		}
+		if len(field.Options) > 0 {
+			selected := field.Default
+			if err := huh.NewForm(huh.NewGroup(
+				huh.NewSelect[string]().Title(title).Options(registrationSelectOptions(field)...).Value(&selected),
+			)).Run(); err != nil {
+				return err
+			}
+			if strings.TrimSpace(selected) == "" {
+				return fmt.Errorf("task field %q requires a value", field.Key)
+			}
+			values[field.Key] = selected
+			continue
+		}
+		value := field.Default
+		input := huh.NewInput().Title(title).Value(&value).Validate(func(value string) error {
+			if strings.TrimSpace(value) == "" {
+				return fmt.Errorf("%s is required", title)
+			}
+			return nil
+		})
+		if err := huh.NewForm(huh.NewGroup(input)).Run(); err != nil {
+			return err
+		}
+		values[field.Key] = value
+	}
+	return nil
+}
+
+func registrationSelectOptions(field task.RegistrationField) []huh.Option[string] {
+	options := make([]huh.Option[string], 0, len(field.Options)+1)
+	if field.Default == "" {
+		// Huh selects the first option when Enter is pressed. Keep an explicit
+		// empty choice first so a missing conventional default cannot silently
+		// become the first real Jira status.
+		options = append(options, huh.NewOption("Select a value...", ""))
+	}
+	for _, option := range field.Options {
+		options = append(options, huh.NewOption(option, option))
+	}
+	return options
+}
+
+func registrationTaskConfig(reg task.Registration, supplied kvFlags, repoName string) (config.RawValues, error) {
+	known := make(map[string]task.RegistrationField, len(reg.Fields))
+	for _, field := range reg.Fields {
+		if strings.TrimSpace(field.Key) == "" {
+			return nil, errorsForRegistration("task plugin returned an empty registration key")
+		}
+		if _, exists := known[field.Key]; exists {
+			return nil, errorsForRegistration(fmt.Sprintf("duplicate task registration key %q", field.Key))
+		}
+		known[field.Key] = field
+	}
+	out := config.RawValues{}
+	for key, value := range supplied {
+		field, ok := known[key]
+		if !ok {
+			return nil, errorsForRegistration(fmt.Sprintf("unknown task key %q", key))
+		}
+		if field.Derived {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q is derived and cannot be overridden", key))
+		}
+		if strings.TrimSpace(value) == "" {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q requires a non-empty value", key))
+		}
+		if len(field.Options) > 0 && !containsRegistrationOption(field.Options, value) {
+			return nil, errorsForRegistration(fmt.Sprintf("task key %q value %q is not one of the available choices", key, value))
+		}
+		if err := setRegistrationValue(out, key, value); err != nil {
+			return nil, err
+		}
+	}
+	for _, field := range reg.Fields {
+		if field.Derived {
+			if err := setRegistrationValue(out, field.Key, repoName); err != nil {
+				return nil, err
+			}
+			continue
+		}
+		if registrationValue(out, field.Key) == "" {
+			return nil, errorsForRegistration(fmt.Sprintf("missing required task key %q", field.Key))
+		}
+	}
+	return out, nil
+}
+
+func errorsForRegistration(message string) error { return fmt.Errorf("%s", message) }
+
+func containsRegistrationOption(options []string, value string) bool {
+	for _, option := range options {
+		if option == value {
+			return true
+		}
+	}
+	return false
+}
+
+func registrationValue(values config.RawValues, key string) string {
+	parts := strings.Split(key, ".")
+	var current any = map[string]any(values)
+	for _, part := range parts {
+		var next map[string]any
+		switch value := current.(type) {
+		case map[string]any:
+			next = value
+		case config.RawValues:
+			next = map[string]any(value)
+		default:
+			return ""
+		}
+		value, ok := next[part]
+		if !ok {
+			return ""
+		}
+		current = value
+	}
+	value, _ := current.(string)
+	return strings.TrimSpace(value)
+}
+
+func setRegistrationValue(values config.RawValues, key, value string) error {
+	parts := strings.Split(key, ".")
+	if len(parts) == 0 || parts[0] == "" {
+		return errorsForRegistration("task plugin returned an invalid registration key")
+	}
+	current := values
+	for _, part := range parts[:len(parts)-1] {
+		if part == "" {
+			return errorsForRegistration(fmt.Sprintf("task plugin returned an invalid registration key %q", key))
+		}
+		existing, ok := current[part]
+		if !ok {
+			nested := map[string]any{}
+			current[part] = nested
+			current = nested
+			continue
+		}
+		var nested map[string]any
+		switch typed := existing.(type) {
+		case map[string]any:
+			nested = typed
+		case config.RawValues:
+			nested = map[string]any(typed)
+			current[part] = nested
+		default:
+			return errorsForRegistration(fmt.Sprintf("task registration key %q conflicts with another value", key))
+		}
+		current = nested
+	}
+	current[parts[len(parts)-1]] = value
+	return nil
+}
+
+func registerSelectedReposDynamic(ctx context.Context, c *server.Client, candidates []runner.RepoCandidate, selected []int, reg task.Registration, values kvFlags) error {
+	for _, index := range selected {
+		candidate := candidates[index]
+		taskCfg, err := registrationTaskConfig(reg, values, candidate.Name)
+		if err != nil {
+			return fmt.Errorf("%s: %w", candidate.Name, err)
+		}
+		info, err := c.RegisterRepo(ctx, repo.RegisterInput{Name: candidate.Name, Path: candidate.Path, TaskConfig: taskCfg})
+		if err != nil {
+			return fmt.Errorf("%s: %w", candidate.Name, err)
+		}
+		fmt.Println(info.Name)
+	}
+	return nil
+}

package/cmd/relay-flow/serve.go

@@ -565,8 +565,8 @@ func (d *serveDeps) RegisterNodeSession(ctx context.Context, registration runsvc
 func (d *serveDeps) DiscoverRepos(ctx context.Context) ([]runner.RepoCandidate, error) {
 	return d.repos.Discover(ctx)
 }
-func (d *serveDeps) TaskFields(context.Context) ([]string, error) {
-	return d.repos.RequiredRepoKeys(), nil
+func (d *serveDeps) TaskRegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	return d.repos.RegistrationFields(ctx, values)
 }
 func (d *serveDeps) RegisterRepo(ctx context.Context, input repo.RegisterInput) (repo.Info, error) {
 	info, err := d.repos.Register(ctx, input)

package/examples/config-reference.yaml

@@ -101,6 +101,13 @@ repos:
       # relay-flow repo name during repo registration.
       project: PAY
       component: payments
+      # These must be valid statuses in the PAY project. Interactive
+      # registration discovers them; scripted registration passes the same
+      # three keys with --set.
+      statusDefaults:
+        start: To Do
+        work: In Progress
+        end: Done
 
       # Optional repo-level overrides inherit into workflows and nodes.
       # assignee: relay-bot@example.com

package/examples/default-story-workflow.yaml

@@ -11,10 +11,11 @@ taskConfig:
       - To Do
     issueTypes:
       - Story
-    # labels:
-    #   - coding
-    # assignees:
-    #   - owner@example.com
+    labels:
+      - "workflow:true"
+    assignees:
+      - currentUser()
+      # Jira resolves currentUser() to the authenticated Jira email.
   # assignee: default-node-owner@example.com
   # project: PAY
   # component: api
@@ -28,48 +29,62 @@ nodes:
       transitionTo:
         parentStatus: In Progress
     onSuccess:
-      - target: implement
+      - target: coding
         when: The parent story is ready for implementation
 
-  implement:
+  coding:
     type: agent
     agent: build
-    description: Implement the parent story and verify the changes.
-    # nudgePrompt: "Finish {{node}} for {{ticket}} and choose one of: {{nextSteps}}"
+    description: Implement the parent story in the current ticket worktree.
+    nudgePrompt: |
+      Continue working on {{ticket}}. Read the parent {{taskSystem}} ticket
+      {{ticket}} and your assigned ticket {{mailbox}} to understand the requirements. Read
+      the latest feedback, address the requested changes, and work on the next
+      bounded task slice. Return the complete report. Valid choices are:
+      {{nextSteps}}.
     taskConfig:
       # assignee: developer@example.com
       transitionTo:
         taskStatus: In Progress
         # parentStatus: In Progress
     onSuccess:
-      - target: review
+      - target: reviewing
         when: Implementation and verification are complete
     onFailure:
-      - target: implement
+      - target: coding
         when: Implementation needs another pass
 
-  review:
+  reviewing:
     type: agent
     agent: plan
-    description: Review the implementation for correctness, regressions, and missing tests.
-    # nudgePrompt: "Complete the review for {{ticket}}. Valid routes: {{nextSteps}}"
+    description: Review the completed implementation and report required changes.
+    nudgePrompt: |
+      Review {{ticket}}. Read the parent {{taskSystem}} ticket {{ticket}} and
+      your assigned ticket {{mailbox}} to understand the requirements. Re-check the
+      implementation and latest coding feedback, then return the complete
+      report. Valid choices are:
+      {{nextSteps}}.
     taskConfig:
       # assignee: reviewer@example.com
       transitionTo:
         taskStatus: In Progress
         # parentStatus: In Review
     onSuccess:
-      - target: prReview
+      - target: humanReview
         when: The changes are ready for human approval
     onFailure:
-      - target: implement
+      - target: coding
         when: Code changes are required
 
-  prReview:
+  humanReview:
     type: hitl
     agent: plan
-    description: Discuss the pull request with the human and obtain approval.
-    # nudgePrompt: "Review {{ticket}} with the human. Valid routes: {{nextSteps}}"
+    description: Approve the reviewed implementation or request changes.
+    nudgePrompt: |
+      Review the completed work for {{ticket}} with the human. Read the parent
+      {{taskSystem}} ticket {{ticket}} and your assigned ticket {{mailbox}} to
+      understand the requirements. Return the complete report. Valid choices are:
+      {{nextSteps}}.
     taskConfig:
       # assignee: human-reviewer@example.com
       transitionTo:
@@ -79,7 +94,7 @@ nodes:
       - target: end
         when: The human approves the review
     onFailure:
-      - target: implement
+      - target: coding
         when: The human requests code changes
 
   end:

package/internal/harness/opencode/opencode_test.go

@@ -14,7 +14,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/workflow"
 )
 
-const configuredPlugin = "relay-flow-plugin@0.2.6-alpha"
+const configuredPlugin = "relay-flow-plugin@0.2.8-alpha"
 
 func TestBuildCommandArgv(t *testing.T) {
 	t.Setenv("RELAY_FLOW_HOME", "/var/lib/relay-flow-test")

package/internal/harness/opencode/repo_setup.go

@@ -10,7 +10,7 @@ import (
 	"github.com/rajpopat27/relay-flow/internal/config"
 )
 
-const relayFlowPlugin = "relay-flow-plugin@0.2.6-alpha"
+const relayFlowPlugin = "relay-flow-plugin@0.2.8-alpha"
 
 type jsoncToken struct {
 	kind       byte

package/internal/repo/service.go

@@ -79,6 +79,12 @@ func (s *Service) RequiredRepoKeys() []string {
 	return keys
 }
 
+// RegistrationFields returns task-plugin-owned registration prompts and
+// choices. Core repo management does not interpret the returned keys.
+func (s *Service) RegistrationFields(ctx context.Context, values config.RawValues) ([]task.RegistrationField, error) {
+	return task.RegistrationFields(ctx, s.taskPlugin, values)
+}
+
 type RegisterInput struct {
 	Name       string
 	Path       string
@@ -116,6 +122,13 @@ func (s *Service) Register(ctx context.Context, input RegisterInput) (Info, erro
 			return Info{}, fmt.Errorf("repo %q: required task config key %q is missing", input.Name, k)
 		}
 	}
+	if err := task.ValidateRegistration(ctx, s.taskPlugin, task.RepoRegistrationSpec{
+		Name:       input.Name,
+		RootConfig: cfg.TaskConfig,
+		RepoConfig: input.TaskConfig,
+	}); err != nil {
+		return Info{}, fmt.Errorf("repo %q: %w", input.Name, err)
+	}
 	// Duplicate registration identity: compute this repo's identity and compare
 	// against every registered repo. Most plugins use their physical task scope;
 	// Beads includes its derived repository label so distinct repositories may

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) {