[CAP-7984] rename taskIdentifier to taskSlug and regenerate types (#333)

GitOrigin-RevId: 803eb91f2a2f5a365c0eb5f1788d4cc7e43949f9

Author: blue-keleher

cmd/runlist.go

@@ -21,9 +21,7 @@ func NewRunListCmd(deps flows.WorkflowDeps) *cobra.Command {
 A task run represents a single execution of a task with specific input parameters.
 This command shows the history of all runs for a given task.
 
-You can specify the task by:
-  • Task ID (e.g., tsk-1234)
-  • Workflow slug and task name (e.g., my-workflow/my-task)
+You can specify the task by its workflow slug and task name (e.g., my-workflow/my-task)
 
 In interactive mode, you will be prompted to select a task if not provided.
 

cmd/task.go

@@ -23,13 +23,11 @@ var taskCmd = &cobra.Command{
 
 func NewTaskStartCmd(deps flows.WorkflowDeps) *cobra.Command {
 	cmd := &cobra.Command{
-		Use:   "start [taskID] --input=<json>",
+		Use:   "start [task-slug] --input=<json>",
 		Short: "Start a task run with the provided input",
 		Long: `Start a task with the provided input.
 
-You can specify the task by:
-  • Task ID (e.g., tsk-1234)
-  • Workflow slug and task name (e.g., my-workflow/my-task)
+You can specify the task by its workflow slug and task name (e.g., my-workflow/my-task)
 
 Input Format:
 The input should be a JSON array where each element is an argument to the task.
@@ -73,15 +71,15 @@ Examples:
 				return fmt.Errorf("failed to parse input: %w", err)
 			}
 
-			if input.TaskID != "" && cmd.Flags().Changed("input") {
+			if input.TaskSlug != "" && cmd.Flags().Changed("input") {
 				command.DefaultFormatNonInteractive(cmd)
 			}
 
 			if nonInteractive, err := command.NonInteractive(cmd, func() (*workflows.TaskRun, error) {
 				taskLoader := deps.WorkflowLoader()
 				return taskLoader.CreateTaskRun(cmd.Context(), input)
 			}, func(j *workflows.TaskRun) string {
-				return text.FormatStringF("Created task run %s for %s", j.Id, input.TaskID)
+				return text.FormatStringF("Created task run %s for %s", j.Id, input.TaskSlug)
 			}); err != nil {
 				return err
 			} else if nonInteractive {

pkg/client/client_gen.go

@@ -16,9 +16,9 @@ type Repo struct {
 	client *client.ClientWithResponses
 }
 
-func (r *Repo) RunTask(ctx context.Context, taskID string, input *workflows.TaskData) (*workflows.TaskRun, error) {
+func (r *Repo) RunTask(ctx context.Context, taskSlug string, input *workflows.TaskData) (*workflows.TaskRun, error) {
 	resp, err := r.client.CreateTaskWithResponse(ctx, client.CreateTaskJSONRequestBody{
-		Task:  taskID,
+		Task:  taskSlug,
 		Input: *input,
 	})
 

pkg/client/types_gen.go

@@ -43,9 +43,9 @@ func NewWorkflow(deps WorkflowDeps, logsFlow *LogFlow, local bool) *Workflow {
 }
 
 func (f *Workflow) TaskRunFlow(ctx context.Context, input *workflowviews.TaskRunInput) tea.Cmd {
-	if input.TaskID == "" {
+	if input.TaskSlug == "" {
 		return f.unspecifiedTask(ctx, func(t *workflows.Task) tea.Cmd {
-			input.TaskID = t.Id
+			input.TaskSlug = t.Id
 			return f.taskRun(ctx, input)
 		})
 	}
@@ -66,9 +66,9 @@ func (f *Workflow) TaskListFlow(ctx context.Context, input *workflowviews.TaskLi
 }
 
 func (f *Workflow) RunListFlow(ctx context.Context, input *workflowviews.TaskRunListInput) tea.Cmd {
-	if input.TaskID == "" {
+	if input.TaskSlug == "" {
 		return f.unspecifiedTask(ctx, func(t *workflows.Task) tea.Cmd {
-			input.TaskID = t.Id
+			input.TaskSlug = t.Id
 			return f.runList(ctx, input, func(tr *workflows.TaskRun) tea.Cmd {
 				return f.runListPalette(ctx, tr)
 			})
@@ -292,14 +292,14 @@ func (f *Workflow) taskListPalette(ctx context.Context, t *workflows.Task) tea.C
 				Name:        "runs",
 				Description: "View all runs for this task",
 				Action: func(ctx context.Context, args []string) tea.Cmd {
-					return f.RunListFlow(ctx, &workflowviews.TaskRunListInput{TaskID: t.Id})
+					return f.RunListFlow(ctx, &workflowviews.TaskRunListInput{TaskSlug: t.Id})
 				},
 			},
 			{
 				Name:        "run",
 				Description: "Start a new task run with inputs",
 				Action: func(ctx context.Context, args []string) tea.Cmd {
-					return f.TaskRunFlow(ctx, &workflowviews.TaskRunInput{TaskID: t.Id})
+					return f.TaskRunFlow(ctx, &workflowviews.TaskRunInput{TaskSlug: t.Id})
 				},
 			},
 		}),
@@ -369,7 +369,7 @@ func (f *Workflow) runDetails(ctx context.Context, input *workflowviews.TaskRunD
 func (f *Workflow) RunDetailsFlow(ctx context.Context, input *workflowviews.TaskRunDetailsInput) tea.Cmd {
 	if input.TaskRunID == "" {
 		return f.unspecifiedTask(ctx, func(t *workflows.Task) tea.Cmd {
-			return f.runList(ctx, &workflowviews.TaskRunListInput{TaskID: t.Id}, func(tr *workflows.TaskRun) tea.Cmd {
+			return f.runList(ctx, &workflowviews.TaskRunListInput{TaskSlug: t.Id}, func(tr *workflows.TaskRun) tea.Cmd {
 				input.TaskRunID = tr.Id
 				return f.runDetails(ctx, input)
 			})

pkg/client/workflows/workflows_gen.go

@@ -66,7 +66,7 @@ func (t *WorkflowLoader) CreateTaskRun(ctx context.Context, input TaskRunInput)
 	if err != nil {
 		return nil, err
 	}
-	return t.taskRepo.RunTask(ctx, input.TaskID, inputData)
+	return t.taskRepo.RunTask(ctx, input.TaskSlug, inputData)
 }
 
 func unmarshalInputData(input string) (*workflows.TaskData, error) {
@@ -276,8 +276,8 @@ func (w *WorkflowLoader) GetTask(ctx context.Context, id string) (*wfclient.Task
 func (w *WorkflowLoader) LoadTaskRunList(ctx context.Context, input TaskRunListInput, cur client.Cursor) (client.Cursor, []*wfclient.TaskRun, error) {
 	pageSize := 20
 	params := &client.ListTaskRunsParams{Limit: &pageSize}
-	if input.TaskID != "" {
-		params.TaskId = pointers.From([]string{input.TaskID})
+	if input.TaskSlug != "" {
+		params.TaskSlug = pointers.From([]string{input.TaskSlug})
 	}
 	if cur != "" {
 		params.Cursor = &cur
@@ -316,8 +316,8 @@ func (w *WorkflowLoader) LoadAllTasks(ctx context.Context, input TaskListInput)
 func (w *WorkflowLoader) LoadAllTaskRuns(ctx context.Context, input TaskRunListInput) ([]*wfclient.TaskRun, error) {
 	pageSize := 100
 	params := &client.ListTaskRunsParams{Limit: &pageSize}
-	if input.TaskID != "" {
-		params.TaskId = pointers.From([]string{input.TaskID})
+	if input.TaskSlug != "" {
+		params.TaskSlug = pointers.From([]string{input.TaskSlug})
 	}
 
 	_, taskRuns, err := w.taskRepo.ListTaskRuns(ctx, params)

pkg/tasks/repo.go

@@ -15,8 +15,8 @@ type TaskListInput struct {
 }
 
 type TaskRunInput struct {
-	TaskID string `cli:"arg:0"`
-	Input  string `cli:"input"`
+	TaskSlug string `cli:"arg:0"`
+	Input    string `cli:"input"`
 }
 
 type TaskRunDetailsInput struct {
@@ -28,8 +28,8 @@ type VersionListInput struct {
 }
 
 type TaskRunListInput struct {
-	TaskID string `cli:"arg:0"`
-	Local  bool
+	TaskSlug string `cli:"arg:0"`
+	Local    bool
 }
 
 type VersionReleaseInput struct {
@@ -49,15 +49,15 @@ func (t TaskListInput) Validate(interactive bool) error {
 }
 
 func (t TaskRunListInput) Validate(interactive bool) error {
-	if !interactive && !t.Local && t.TaskID == "" {
-		return errors.New("task id must be specified when output is not interactive")
+	if !interactive && !t.Local && t.TaskSlug == "" {
+		return errors.New("task slug must be specified when output is not interactive")
 	}
 	return nil
 }
 
 func (t TaskRunInput) Validate(interactive bool) error {
-	if !interactive && t.TaskID == "" {
-		return errors.New("task id must be specified when output is not interactive")
+	if !interactive && t.TaskSlug == "" {
+		return errors.New("task slug must be specified when output is not interactive")
 	}
 
 	if !interactive && t.Input == "" {

pkg/tui/flows/workflow.go

@@ -39,63 +39,63 @@ func TestTaskListInputValidate(t *testing.T) {
 }
 
 func TestTaskRunInputValidate(t *testing.T) {
-	t.Run("non-interactive missing task ID", func(t *testing.T) {
+	t.Run("non-interactive missing task slug", func(t *testing.T) {
 		input := TaskRunInput{Input: `["a"]`}
 		err := input.Validate(false)
 		require.Error(t, err)
-		assert.Contains(t, err.Error(), "task id must be specified")
+		assert.Contains(t, err.Error(), "task slug must be specified")
 	})
 
 	t.Run("non-interactive missing input", func(t *testing.T) {
-		input := TaskRunInput{TaskID: "tsk-1"}
+		input := TaskRunInput{TaskSlug: "tsk-1"}
 		err := input.Validate(false)
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "input must be specified")
 	})
 
 	t.Run("invalid JSON input errors even in interactive mode", func(t *testing.T) {
-		input := TaskRunInput{TaskID: "tsk-1", Input: "not-json"}
+		input := TaskRunInput{TaskSlug: "tsk-1", Input: "not-json"}
 		err := input.Validate(true)
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "input must be valid JSON")
 	})
 
 	t.Run("valid array JSON", func(t *testing.T) {
-		input := TaskRunInput{TaskID: "tsk-1", Input: `["a","b"]`}
+		input := TaskRunInput{TaskSlug: "tsk-1", Input: `["a","b"]`}
 		assert.NoError(t, input.Validate(false))
 	})
 
 	t.Run("valid object JSON", func(t *testing.T) {
-		input := TaskRunInput{TaskID: "tsk-1", Input: `{"k":"v"}`}
+		input := TaskRunInput{TaskSlug: "tsk-1", Input: `{"k":"v"}`}
 		assert.NoError(t, input.Validate(false))
 	})
 }
 
 func TestTaskRunListInputValidate(t *testing.T) {
-	t.Run("interactive allows empty task ID", func(t *testing.T) {
+	t.Run("interactive allows empty task slug", func(t *testing.T) {
 		input := TaskRunListInput{}
 		assert.NoError(t, input.Validate(true))
 	})
 
-	t.Run("non-interactive requires task ID", func(t *testing.T) {
+	t.Run("non-interactive requires task slug", func(t *testing.T) {
 		input := TaskRunListInput{}
 		err := input.Validate(false)
 		require.Error(t, err)
-		assert.Contains(t, err.Error(), "task id must be specified")
+		assert.Contains(t, err.Error(), "task slug must be specified")
 	})
 
-	t.Run("non-interactive with task ID succeeds", func(t *testing.T) {
-		input := TaskRunListInput{TaskID: "tsk-1"}
+	t.Run("non-interactive with task slug succeeds", func(t *testing.T) {
+		input := TaskRunListInput{TaskSlug: "tsk-1"}
 		assert.NoError(t, input.Validate(false))
 	})
 
-	t.Run("non-interactive local allows empty task ID", func(t *testing.T) {
+	t.Run("non-interactive local allows empty task slug", func(t *testing.T) {
 		input := TaskRunListInput{Local: true}
 		assert.NoError(t, input.Validate(false))
 	})
 
-	t.Run("non-interactive local with task ID succeeds", func(t *testing.T) {
-		input := TaskRunListInput{TaskID: "tsk-1", Local: true}
+	t.Run("non-interactive local with task slug succeeds", func(t *testing.T) {
+		input := TaskRunListInput{TaskSlug: "tsk-1", Local: true}
 		assert.NoError(t, input.Validate(false))
 	})
 }