package workspaceissues import ( "context" "strings" ) func (s Service) ListIssues(ctx context.Context, filter IssueListFilter) (IssueList, error) { store, err := s.store() if err != nil { return IssueList{}, err } filter.WorkspaceID = strings.TrimSpace(filter.WorkspaceID) filter.TopicID = strings.TrimSpace(filter.TopicID) if filter.WorkspaceID == "" || filter.TopicID == "" { return IssueList{}, ErrInvalidArgument } if filter.StatusFilter != "" { if _, ok := NormalizeStatus(string(filter.StatusFilter)); !ok { return IssueList{}, ErrInvalidArgument } } filter.SearchQuery = strings.TrimSpace(filter.SearchQuery) if _, err := store.GetTopic(ctx, filter.WorkspaceID, filter.TopicID); err != nil { return IssueList{}, err } list, err := store.ListIssues(ctx, filter) if err != nil { return IssueList{}, err } list.NextPageToken = EncodeIssueListCursorToken(list.NextCursor) return list, nil } func (s Service) CreateIssue(ctx context.Context, input CreateIssueInput) (Issue, error) { store, err := s.store() if err != nil { return Issue{}, err } issue, err := s.buildIssue(ctx, store, input) if err != nil { return Issue{}, err } created, err := store.CreateIssue(ctx, issue) if err != nil { return Issue{}, err } if err := store.TouchTopicActivity(ctx, issue.WorkspaceID, issue.TopicID, issue.UpdatedAtUnixMS); err != nil { return Issue{}, err } return created, nil } func (s Service) buildIssue(ctx context.Context, store Store, input CreateIssueInput) (Issue, error) { if input.SequentialExecution && input.ParallelExecution { return Issue{}, ErrInvalidArgument } workspaceID := strings.TrimSpace(input.WorkspaceID) topicID := strings.TrimSpace(input.TopicID) actorUserID := strings.TrimSpace(input.ActorUserID) title := strings.TrimSpace(input.Title) if workspaceID == "" || topicID == "" || actorUserID == "" || title == "" { return Issue{}, ErrInvalidArgument } if _, err := store.GetTopic(ctx, workspaceID, topicID); err != nil { return Issue{}, err } planningSource := PlanningSourceManual if strings.TrimSpace(input.PlanningSource) != "" { var ok bool planningSource, ok = NormalizePlanningSource(input.PlanningSource) if !ok { return Issue{}, ErrInvalidArgument } } profile := DefaultExecutionProfile() if input.HasExecutionProfile { var ok bool profile, ok = NormalizeExecutionProfile(input.ExecutionProfile) if !ok { return Issue{}, ErrInvalidArgument } } budget := DefaultBudget() if input.HasBudget { var ok bool budget, ok = NormalizeBudget(input.Budget) if !ok { return Issue{}, ErrInvalidArgument } } now := s.nowUnixMS() issue := Issue{ IssueID: s.resolveID(IDKindIssue, input.IssueID), TopicID: topicID, WorkspaceID: workspaceID, Title: title, Content: strings.TrimSpace(input.Content), SearchText: TrimSearchText(input.Content), Status: StatusNotStarted, PlanningSource: planningSource, SourceSessionID: strings.TrimSpace(input.SourceSessionID), SequentialExecution: input.SequentialExecution, ParallelExecution: input.ParallelExecution, ExecutionProfile: profile, Budget: budget, CreatorUserID: actorUserID, CreatedAtUnixMS: now, UpdatedAtUnixMS: now, } if issue.IssueID == "" { return Issue{}, ErrInvalidArgument } return issue, nil } func (s Service) UpdateIssue(ctx context.Context, input UpdateIssueInput) (Issue, error) { store, err := s.store() if err != nil { return Issue{}, err } workspaceID := strings.TrimSpace(input.WorkspaceID) issueID := strings.TrimSpace(input.IssueID) if workspaceID == "" || issueID == "" || strings.TrimSpace(input.ActorUserID) == "" { return Issue{}, ErrInvalidArgument } issue, err := store.GetIssue(ctx, workspaceID, issueID) if err != nil { return Issue{}, err } if err := RejectManagedIssueMutation(issue); err != nil { return Issue{}, err } if input.HasTitle { title := strings.TrimSpace(input.Title) if title == "" { return Issue{}, ErrInvalidArgument } issue.Title = title } if input.HasContent { issue.Content = strings.TrimSpace(input.Content) issue.SearchText = TrimSearchText(input.Content) } if input.HasStatus { status, ok := NormalizeStatus(input.Status) if !ok { return Issue{}, ErrInvalidArgument } issue.Status = status } if input.HasDispatchPaused { issue.DispatchPaused = input.DispatchPaused } if input.HasExecutionProfile { profile, ok := NormalizeExecutionProfile(input.ExecutionProfile) if !ok { return Issue{}, ErrInvalidArgument } issue.ExecutionProfile = profile if issue.Budget.Mode == BudgetModeAuto { issue.Budget.TokenLimit = CompileAutoTokenBudget(maxInt(issue.TaskCount, 1), profile) } } if input.HasBudget { budget, ok := NormalizeBudget(input.Budget) if !ok { return Issue{}, ErrInvalidArgument } budget.ConsumedTokens = issue.Budget.ConsumedTokens if !budget.HasRemainingQuota { budget.RemainingQuotaPercent = issue.Budget.RemainingQuotaPercent budget.HasRemainingQuota = issue.Budget.HasRemainingQuota } if budget.Mode == BudgetModeAuto { budget.TokenLimit = CompileAutoTokenBudget(maxInt(issue.TaskCount, 1), issue.ExecutionProfile) } budget.Status = BudgetStatusActive if budget.TokenLimit > 0 && budget.ConsumedTokens >= budget.TokenLimit { budget.Status = BudgetStatusSoftLimited } if budget.HasRemainingQuota && budget.RemainingQuotaPercent <= budget.QuotaWaterlinePercent { budget.Status = BudgetStatusSoftLimited } issue.Budget = budget } issue.UpdatedAtUnixMS = s.nowUnixMS() updated, err := store.UpdateIssue(ctx, issue) if err != nil { return Issue{}, err } if err := store.TouchTopicActivity(ctx, workspaceID, issue.TopicID, issue.UpdatedAtUnixMS); err != nil { return Issue{}, err } return updated, nil } func (s Service) GetIssueDetail(ctx context.Context, workspaceID string, issueID string) (IssueDetail, error) { store, err := s.store() if err != nil { return IssueDetail{}, err } workspaceID = strings.TrimSpace(workspaceID) issueID = strings.TrimSpace(issueID) if workspaceID == "" || issueID == "" { return IssueDetail{}, ErrInvalidArgument } issue, err := store.GetIssue(ctx, workspaceID, issueID) if err != nil { return IssueDetail{}, err } tasks, err := store.ListTasks(ctx, TaskListFilter{ WorkspaceID: workspaceID, IssueID: issueID, ReturnAll: true, }) if err != nil { return IssueDetail{}, err } refs, err := store.ListContextRefs(ctx, workspaceID, issueID, "", ContextRefParentIssue) if err != nil { return IssueDetail{}, err } runs, err := store.ListRuns(ctx, workspaceID, issueID, "") if err != nil { return IssueDetail{}, err } var latestRun *Run if len(runs) > 0 { latestRun = &runs[0] } outputs := make([]RunOutput, 0) seenOutputPaths := map[string]struct{}{} for _, run := range runs { runOutputs, err := store.ListRunOutputs(ctx, workspaceID, issueID, run.TaskID, run.RunID) if err != nil { return IssueDetail{}, err } for _, output := range runOutputs { outputPath := strings.TrimSpace(output.Path) if _, exists := seenOutputPaths[outputPath]; exists { continue } seenOutputPaths[outputPath] = struct{}{} outputs = append(outputs, output) } } return IssueDetail{ Issue: issue, Tasks: tasks.Items, ContextRefs: refs, LatestRun: latestRun, RecentRuns: runs, LatestOutputs: outputs, }, nil } const ( defaultIssueOutputSearchLimit = 50 maxIssueOutputSearchLimit = 200 ) // SearchIssueOutputs searches produced output files across one workspace by file // name, deduplicated by path and ordered by recency. IssueID / TopicID optionally // scope the search; IssueID wins when both are set. // normalizeRunOutputFilters trims、去重、丢弃空白的「文件类型筛选分类」id。 func normalizeRunOutputFilters(filters []string) []string { if len(filters) == 0 { return nil } seen := map[string]bool{} out := make([]string, 0, len(filters)) for _, filter := range filters { filter = strings.TrimSpace(filter) if filter == "" || seen[filter] { continue } seen[filter] = true out = append(out, filter) } return out } func (s Service) SearchIssueOutputs(ctx context.Context, params RunOutputSearchParams) ([]RunOutputSearchHit, error) { store, err := s.store() if err != nil { return nil, err } params.WorkspaceID = strings.TrimSpace(params.WorkspaceID) params.Query = strings.TrimSpace(params.Query) params.IssueID = strings.TrimSpace(params.IssueID) params.TopicID = strings.TrimSpace(params.TopicID) params.Filters = normalizeRunOutputFilters(params.Filters) // 筛选与搜索是同一能力:关键词与筛选同时为空才算无效查询。仅选类型筛选(Query 空)时 // 由 store 按类型 list-all。 if params.WorkspaceID == "" || (params.Query == "" && len(params.Filters) == 0) { return nil, ErrInvalidArgument } if params.Limit <= 0 { params.Limit = defaultIssueOutputSearchLimit } if params.Limit > maxIssueOutputSearchLimit { params.Limit = maxIssueOutputSearchLimit } return store.SearchRunOutputs(ctx, params) } func (s Service) DeleteIssue(ctx context.Context, workspaceID string, issueID string, actorUserID string) (bool, error) { store, err := s.store() if err != nil { return false, err } workspaceID = strings.TrimSpace(workspaceID) issueID = strings.TrimSpace(issueID) actorUserID = strings.TrimSpace(actorUserID) if workspaceID == "" || issueID == "" || 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.DeleteIssue(ctx, workspaceID, issueID, actorUserID) if err != nil { return false, err } if !removed { return false, ErrIssueNotFound } if err := store.TouchTopicActivity(ctx, workspaceID, issue.TopicID, s.nowUnixMS()); err != nil { return false, err } return true, nil }