tutti/packages/workspace/issues/service_tasks.go

package workspaceissues

import (
	"context"
	"strings"
)

func (s Service) ListTasks(ctx context.Context, filter TaskListFilter) (TaskList, error) {
	store, err := s.store()
	if err != nil {
		return TaskList{}, err
	}
	filter.WorkspaceID = strings.TrimSpace(filter.WorkspaceID)
	filter.IssueID = strings.TrimSpace(filter.IssueID)
	if filter.WorkspaceID == "" || filter.IssueID == "" {
		return TaskList{}, ErrInvalidArgument
	}
	if filter.StatusFilter != "" {
		if _, ok := NormalizeStatus(string(filter.StatusFilter)); !ok {
			return TaskList{}, ErrInvalidArgument
		}
	}
	filter.SearchQuery = strings.TrimSpace(filter.SearchQuery)
	if _, err := store.GetIssue(ctx, filter.WorkspaceID, filter.IssueID); err != nil {
		return TaskList{}, err
	}
	list, err := store.ListTasks(ctx, filter)
	if err != nil {
		return TaskList{}, err
	}
	list.NextPageToken = EncodeTaskListCursorToken(list.NextCursor)
	return list, nil
}

func (s Service) CreateTask(ctx context.Context, input CreateTaskInput) (Task, error) {
	tasks, err := s.CreateTasks(ctx, CreateTasksInput{
		IssueID:     input.IssueID,
		WorkspaceID: input.WorkspaceID,
		ActorUserID: input.ActorUserID,
		Tasks: []CreateTaskItemInput{{
			TaskID:             input.TaskID,
			Title:              input.Title,
			Content:            input.Content,
			Priority:           input.Priority,
			DueAtUnixMS:        input.DueAtUnixMS,
			AgentTargetID:      input.AgentTargetID,
			ModelPlanID:        input.ModelPlanID,
			Model:              input.Model,
			PermissionModeID:   input.PermissionModeID,
			ReasoningEffort:    input.ReasoningEffort,
			ExecutionDirectory: input.ExecutionDirectory,
			DependencyTaskIDs:  input.DependencyTaskIDs,
			Parallelizable:     input.Parallelizable,
			AutoAccept:         input.AutoAccept,
		}},
	})
	if err != nil {
		return Task{}, err
	}
	if len(tasks) != 1 {
		return Task{}, ErrInvalidArgument
	}
	return tasks[0], nil
}

func (s Service) CreateTasks(ctx context.Context, input CreateTasksInput) ([]Task, error) {
	store, err := s.store()
	if err != nil {
		return nil, err
	}
	workspaceID := strings.TrimSpace(input.WorkspaceID)
	issueID := strings.TrimSpace(input.IssueID)
	actorUserID := strings.TrimSpace(input.ActorUserID)
	if workspaceID == "" || issueID == "" || actorUserID == "" || len(input.Tasks) == 0 {
		return nil, ErrInvalidArgument
	}
	issue, err := store.GetIssue(ctx, workspaceID, issueID)
	if err != nil {
		return nil, err
	}
	if err := RejectManagedIssueMutation(issue); err != nil {
		return nil, err
	}
	tasks, err := s.buildTasks(issue, actorUserID, input.Tasks)
	if err != nil {
		return nil, err
	}
	existing, err := store.ListTasks(ctx, TaskListFilter{WorkspaceID: workspaceID, IssueID: issueID, ReturnAll: true})
	if err != nil {
		return nil, err
	}
	graph := append(append([]Task(nil), existing.Items...), tasks...)
	if !ValidateTaskDependencyGraph(graph) {
		return nil, ErrInvalidArgument
	}
	created, err := store.AppendTasks(ctx, tasks)
	if err != nil {
		return nil, err
	}
	projected, err := store.RecalculateIssueProjection(ctx, workspaceID, issueID)
	if err != nil {
		return nil, err
	}
	if projected.Budget.Mode == BudgetModeAuto {
		projected.Budget.TokenLimit = CompileAutoTokenBudget(projected.TaskCount, projected.ExecutionProfile)
		if _, err := store.UpdateIssue(ctx, projected); err != nil {
			return nil, err
		}
	}
	if err := store.TouchTopicActivity(ctx, workspaceID, issue.TopicID, s.nowUnixMS()); err != nil {
		return nil, err
	}
	return created, nil
}

func (s Service) buildTasks(issue Issue, actorUserID string, items []CreateTaskItemInput) ([]Task, error) {
	now := s.nowUnixMS()
	tasks := make([]Task, 0, len(items))
	for _, item := range items {
		title := strings.TrimSpace(item.Title)
		if title == "" {
			return nil, ErrInvalidArgument
		}
		agentTargetID := strings.TrimSpace(item.AgentTargetID)
		modelPlanID := strings.TrimSpace(item.ModelPlanID)
		model := strings.TrimSpace(item.Model)
		if agentTargetID == "" && (modelPlanID != "" || model != "") {
			return nil, ErrInvalidArgument
		}
		task := Task{
			TaskID:             s.resolveID(IDKindTask, item.TaskID),
			IssueID:            issue.IssueID,
			WorkspaceID:        issue.WorkspaceID,
			Title:              title,
			Content:            strings.TrimSpace(item.Content),
			SearchText:         TrimSearchText(item.Content),
			Status:             StatusNotStarted,
			Priority:           NormalizePriority(item.Priority),
			DueAtUnixMS:        maxInt64(item.DueAtUnixMS, 0),
			AgentTargetID:      agentTargetID,
			ModelPlanID:        modelPlanID,
			Model:              model,
			PermissionModeID:   strings.TrimSpace(item.PermissionModeID),
			ReasoningEffort:    strings.TrimSpace(item.ReasoningEffort),
			ExecutionDirectory: strings.TrimSpace(item.ExecutionDirectory),
			DependencyTaskIDs:  NormalizeDependencyTaskIDs(item.DependencyTaskIDs),
			Parallelizable:     item.Parallelizable,
			AutoAccept:         item.AutoAccept,
			AcceptanceState:    AcceptanceAgentClaimed,
			CreatorUserID:      actorUserID,
			CreatedAtUnixMS:    now,
			UpdatedAtUnixMS:    now,
		}
		if task.TaskID == "" {
			return nil, ErrInvalidArgument
		}
		tasks = append(tasks, task)
	}
	return tasks, nil
}

func (s Service) UpdateTask(ctx context.Context, input UpdateTaskInput) (Task, error) {
	store, err := s.store()
	if err != nil {
		return Task{}, err
	}
	workspaceID := strings.TrimSpace(input.WorkspaceID)
	issueID := strings.TrimSpace(input.IssueID)
	taskID := strings.TrimSpace(input.TaskID)
	if workspaceID == "" || issueID == "" || taskID == "" || strings.TrimSpace(input.ActorUserID) == "" {
		return Task{}, ErrInvalidArgument
	}
	issue, err := store.GetIssue(ctx, workspaceID, issueID)
	if err != nil {
		return Task{}, err
	}
	if err := RejectManagedIssueMutation(issue); err != nil {
		return Task{}, err
	}
	task, err := store.GetTask(ctx, workspaceID, issueID, taskID)
	if err != nil {
		return Task{}, err
	}
	if input.HasTitle {
		title := strings.TrimSpace(input.Title)
		if title == "" {
			return Task{}, ErrInvalidArgument
		}
		task.Title = title
	}
	if input.HasContent {
		task.Content = strings.TrimSpace(input.Content)
		task.SearchText = TrimSearchText(input.Content)
	}
	if input.HasStatus {
		status, ok := NormalizeStatus(input.Status)
		if !ok {
			return Task{}, ErrInvalidArgument
		}
		task.Status = status
	}
	if input.HasPriority {
		task.Priority = NormalizePriority(input.Priority)
	}
	if input.HasDueAt {
		task.DueAtUnixMS = input.DueAtUnixMS
	}
	if input.HasSortIndex {
		if input.SortIndex < 0 {
			return Task{}, ErrInvalidArgument
		}
		task.SortIndex = input.SortIndex
	}
	if input.HasAgentTargetID {
		task.AgentTargetID = strings.TrimSpace(input.AgentTargetID)
	}
	if input.HasModelPlanID {
		task.ModelPlanID = strings.TrimSpace(input.ModelPlanID)
	}
	if input.HasModel {
		task.Model = strings.TrimSpace(input.Model)
	}
	if task.AgentTargetID == "" && (task.ModelPlanID != "" || task.Model != "") {
		return Task{}, ErrInvalidArgument
	}
	if input.HasExecutionDirectory {
		task.ExecutionDirectory = strings.TrimSpace(input.ExecutionDirectory)
	}
	if input.HasDependencyTaskIDs {
		task.DependencyTaskIDs = NormalizeDependencyTaskIDs(input.DependencyTaskIDs)
	}
	if input.HasParallelizable {
		task.Parallelizable = input.Parallelizable
	}
	if input.HasAutoAccept {
		task.AutoAccept = input.AutoAccept
	}
	if task.AcceptanceState == "" {
		if task.Status == StatusCompleted || task.Status == StatusPendingAcceptance {
			task.AcceptanceState = AcceptanceAutoChecked
		} else {
			task.AcceptanceState = AcceptanceAgentClaimed
		}
	}
	if input.HasAcceptanceState {
		next, ok := NormalizeAcceptanceState(input.AcceptanceState)
		if !ok || !CanTransitionAcceptance(task.AcceptanceState, next) {
			return Task{}, ErrInvalidArgument
		}
		task.AcceptanceState = next
	}
	if input.HasAcceptanceSummary {
		task.AcceptanceSummary = strings.TrimSpace(input.AcceptanceSummary)
	}
	if input.HasStatus {
		switch task.Status {
		case StatusCompleted:
			if !input.HasAcceptanceState && CanTransitionAcceptance(task.AcceptanceState, AcceptanceUserAccepted) {
				task.AcceptanceState = AcceptanceUserAccepted
			}
			if task.AcceptanceState != AcceptanceUserAccepted {
				return Task{}, ErrInvalidArgument
			}
		case StatusNotStarted:
			task.AcceptanceState = AcceptanceAgentClaimed
			task.AcceptanceSummary = ""
		case StatusPendingAcceptance:
			// An accepted task cannot be pushed back to pending acceptance:
			// that write would keep user_accepted on a non-completed task and
			// wedge the dispatch frontier. Rework goes through not_started.
			if task.AcceptanceState == AcceptanceUserAccepted {
				return Task{}, ErrInvalidArgument
			}
		}
	}
	task.UpdatedAtUnixMS = s.nowUnixMS()
	updated, err := store.UpdateTask(ctx, task)
	if err != nil {
		return Task{}, err
	}
	if _, err := store.RecalculateIssueProjection(ctx, workspaceID, issueID); err != nil {
		return Task{}, err
	}
	if err := store.TouchTopicActivity(ctx, workspaceID, issue.TopicID, task.UpdatedAtUnixMS); err != nil {
		return Task{}, err
	}
	return updated, nil
}

func (s Service) GetTaskDetail(ctx context.Context, workspaceID string, issueID string, taskID string) (TaskDetail, error) {
	store, err := s.store()
	if err != nil {
		return TaskDetail{}, err
	}
	workspaceID = strings.TrimSpace(workspaceID)
	issueID = strings.TrimSpace(issueID)
	taskID = strings.TrimSpace(taskID)
	if workspaceID == "" || issueID == "" || taskID == "" {
		return TaskDetail{}, ErrInvalidArgument
	}
	task, err := store.GetTask(ctx, workspaceID, issueID, taskID)
	if err != nil {
		return TaskDetail{}, err
	}
	refs, err := store.ListContextRefs(ctx, workspaceID, issueID, taskID, ContextRefParentTask)
	if err != nil {
		return TaskDetail{}, err
	}
	runs, err := store.ListRuns(ctx, workspaceID, issueID, taskID)
	if err != nil {
		return TaskDetail{}, err
	}
	var latestRun *Run
	if len(runs) > 0 {
		latestRun = &runs[0]
	}
	outputs, err := store.ListLatestRunOutputs(ctx, workspaceID, issueID, taskID)
	if err != nil {
		return TaskDetail{}, err
	}
	return TaskDetail{
		Task:          task,
		ContextRefs:   refs,
		LatestRun:     latestRun,
		RecentRuns:    runs,
		LatestOutputs: outputs,
	}, nil
}

func (s Service) DeleteTask(ctx context.Context, workspaceID string, issueID string, taskID string, actorUserID string) (bool, error) {
	store, err := s.store()
	if err != nil {
		return false, err
	}
	workspaceID = strings.TrimSpace(workspaceID)
	issueID = strings.TrimSpace(issueID)
	taskID = strings.TrimSpace(taskID)
	actorUserID = strings.TrimSpace(actorUserID)
	if workspaceID == "" || issueID == "" || taskID == "" || actorUserID == "" {
		return false, ErrInvalidArgument
	}
	issue, err := store.GetIssue(ctx, workspaceID, issueID)
	if err != nil {
		return false, err
	}
	if err := RejectManagedIssueMutation(issue); err != nil {
		return false, err
	}
	removed, err := store.DeleteTask(ctx, workspaceID, issueID, taskID, actorUserID)
	if err != nil {
		return false, err
	}
	if !removed {
		return false, ErrTaskNotFound
	}
	if _, err := store.RecalculateIssueProjection(ctx, workspaceID, issueID); err != nil {
		return false, err
	}
	if err := store.TouchTopicActivity(ctx, workspaceID, issue.TopicID, s.nowUnixMS()); err != nil {
		return false, err
	}
	return true, nil
}