dfaab11959
* feat(backend): full GitLab parity — store, service, poller, WS, presets Add the watcher/poll/write-action surface on top of the existing GitLab client + service skeleton: * 5 new SQLite tables (mr_watches, review_watches, review_mr_tasks, issue_watches, issue_watch_tasks, action_presets) + CRUD * Client + Service: MergeMR, GetProjectMergeMethods, GetProtectedBranch, ListUserProjects, SearchProjects, SetMRLabels, SetMRAssignees * Service: review/issue/MR watch CRUD + Check/Trigger, GetStats, CleanupAllReview/IssueTasks (cleanup-policy aware), TriggerMRSync, action-presets CRUD with defaults * Background poller (MR / review / issue loops) wired from main.go * ~35 GitLab WS action constants + handlers.go registrations * Mock controller for E2E seeding (MRs, issues, pipelines, discussions, approvals, branches) * eventBus + taskDeleter + taskSessionChecker plumbed through Service * Event types: GitLabMRFeedback / NewReviewMR / NewIssue / TaskMRUpdated * feat(web): GitLab frontend parity — types, API, store slice, domain hooks Extend the frontend GitLab integration on top of the new backend surface: * HTTP API client expansion (gitlab-api.ts): full CRUD for review/issue/MR watches, MR write actions (merge/approve/labels/assignees), MR files/commits/feedback, action presets, projects autocomplete, stats * Store slice expansion: review/issue/MR watches lists, action presets by workspace, stats + status with loading flags. Properties prefixed with gitlab to avoid collision with GitHub slice * Domain hooks: use-gitlab-status, use-gitlab-stats, use-gitlab-review-watches, use-gitlab-issue-watches, use-gitlab-action-presets — mirror github hook shapes * Type model: ReviewWatch, IssueWatch, MRWatch, ActionPresets, Stats, ProjectMergeMethods, MRApproval, Pipeline, MRFeedback, etc. * Backend controller HTTP routes for watches/presets/write-actions/ projects/stats so the frontend HTTP API client has endpoints to hit All passes: backend (build + vet + lint + tests), web (typecheck + lint + 2400 tests). * fix(gitlab): wire orchestrator event handlers, fix label-filter drop, add tests Address Claude review blockers on the parity PR: 1. Wire orchestrator subscriptions for GitLab review/issue watch events. Add event_handlers_gitlab.go with handleGitLabNewReviewMR / handleGitLabNewIssue, dedup reservation handshake, and task-creator interfaces (mirrors event_handlers_github.go). main.go now calls orchestratorSvc.SetGitLabService so the dedup APIs are usable 2. Fix silent label-filter drop: when a custom_query is set on an issue watch, labels were being appended to the unused filter arg. Fold labels into customQuery (or default filter) so they actually reach GitLab; extracted appendLabelsToQuery helper with explicit handling of pre-existing labels= clauses 3. Switch event payloads to pointer types (mirrors GitHub) so handlers can type-assert pointer events 4. Backend tests: store_watches_test.go (CRUD + reserve/assign for all 4 new tables + presets), service_watches_test.go (label-filter helper, cleanup policy, project normalisation), action_presets_test.go 5. Frontend slice tests: review/issue watch CRUD round-trips, action presets + stats reducer coverage All green: backend (build+vet+lint+tests), web (typecheck+lint+2403 tests). * fix(gitlab): address remaining blockers — cleanup wiring, safe defaults, nil guards Address the second round of Claude review blockers: 1. main.go: wire SetTaskDeleter + SetTaskSessionChecker on services.GitLab (mirrors GitHub). Without these, manual cleanup sweeps would always error with "task deleter not configured" 2. service_cleanup.go: default cleanup policy on transient DB error is now CleanupPolicyNever (preserve tasks) instead of CleanupPolicyAuto (silently delete). Genuine "watch was deleted" path also falls under the safe-side default; user can manually delete the orphan tasks 3. service_watches.go: add nil guards on requireStore() so the 6 MR-watch list/get/delete methods return an errStoreUnavailable error instead of panicking when the SQLite store failed to construct at boot 4. use-gitlab-status.ts + use-gitlab-stats.ts: add per-mount attemptedRef so an unreachable GitLab doesn't trigger an infinite re-fetch loop — the previous useEffect re-ran every render because the failure path left status null, satisfying the !status guard * fix(gitlab): propagate session-check errors, clamp poll interval on update Address remaining Claude blockers: * service_cleanup.go: HasUserAuthoredMessage transient errors are now preserved (return false → skip delete) instead of silently ignored; the alternative was occasionally deleting tasks a user had touched * service_watches.go: extract clampPollInterval helper applying the same bounds (0 → default, <60 → 60) as the create path; both applyReviewWatchPatch and applyIssueWatchPatch use it so user-supplied zero or tiny values via UpdateXxxWatchRequest no longer hammer GitLab * fix(gitlab): clear dupl lint, fix preset retry loop + per-workspace watch cache * service_watches.go: applyReviewWatchPatch / applyIssueWatchPatch get nolint:dupl markers — they share shape but per-domain field validation lives in the create paths, so deduplicating via generics would obscure the contract. Restores backend lint to 0 issues * use-gitlab-action-presets.ts: per-workspace attemptedRef set so a failing preset fetch doesn't retry on every render * use-gitlab-review-watches.ts + use-gitlab-issue-watches.ts: track lastFetchedRef per consumer so a workspace switch triggers a refetch. The slice-level loaded flag is shared across instances and can't double as a per-workspace cache key * fix(gitlab): add nil-store guards across review/issue watch + cleanup paths Round-3 Claude finding: ReviewWatch / IssueWatch / preset / reservation methods still called s.requireStore().X() directly. If NewStore fails at boot (table migration error), the service struct's store is nil and every list/get/update/create/reserve method panics on first request. Apply the same store-nil → errStoreUnavailable pattern from f95a929 to every remaining method: * CreateReviewWatch / CreateIssueWatch * GetReviewWatch / ListReviewWatches / ListAllReviewWatches / UpdateReviewWatch / TriggerReviewWatchAll * GetIssueWatch / ListIssueWatches / ListAllIssueWatches / UpdateIssueWatch / TriggerIssueWatchAll * ReserveReviewMRTask / AssignReviewMRTaskID / ReleaseReviewMRTask * ReserveIssueWatchTask / AssignIssueWatchTaskID / ReleaseIssueWatchTask * lookupReviewPolicy / lookupIssuePolicy (return CleanupPolicyNever) * fix(gitlab): nil-store guards on CheckXxxWatch + DeleteXxxWatch + cleanup paths Round-4 Claude finding: 4 remaining panic sites the previous nil-guard pass missed — these run from the background poller (every 5 min) and the manual delete/cleanup flows, so a boot-time NewStore failure would crash the orchestrator process on first tick. * service_watches.go: add store-nil guards to DeleteReviewWatch / DeleteIssueWatch / CheckReviewWatch / CheckIssueWatch * service_cleanup.go: guard CleanupAllReviewTasks / CleanupAllIssueTasks entry points; wrap the trailing DeleteReviewMRTask / DeleteIssueWatchTask calls in `if store := s.requireStore(); store != nil` blocks so the cleanup succeeds even when the dedup-row delete is unreachable * refactor(gitlab): split service_watches.go to stay under 800-line revive limit CI's --new-from-rev lint caught service_watches.go at 808 lines (limit 800). Split into three focused files: * service_events.go (94 LOC) — publish helpers for MR feedback / new review MR / new issue / watch lifecycle events * service_issue_watches.go (302 LOC) — Issue watch CRUD + Check + Trigger + fetch + helpers * service_reservations.go (59 LOC) — Reserve/Assign/Release dedup handles used by the orchestrator event handlers service_watches.go is now 505 lines and contains MR watch + Review watch only. No behavioral change. * fix(gitlab): address inline code-review feedback Address actionable inline comments from Claude/CodeRabbit/cubic/Greptile: * appendLabelsToQuery: use url.ParseQuery for exact key match instead of strings.Contains; previously false-matched keys like mylabels= and silently dropped the watch's labels (test added) * fetchReviewMRs: drop dead `filter = watch.CustomQuery` assignment — SearchMRs's buildMRSearchQuery returns customQuery verbatim and ignores filter when customQuery is non-empty * store.go: add workspace_id indexes on gitlab_review_watches and gitlab_issue_watches (the 5-min poller and HTTP list endpoints did full table scans) * mock_client.SearchProjects: switch from == to case-insensitive Contains so partial-query autocomplete returns the seeded project, matching the doc comment * Poller: add sync.Mutex to guard `started` field; Start/Stop are now safe to call concurrently (go test -race would have flagged the previous read/write race) * Add ErrWatchNotFound sentinel; controller_watches.go maps it to HTTP 404 via httpRespondError helper. Update/Trigger handlers previously returned 500 for missing watches, hiding the distinction from real server faults * service_events.go: log Publish errors on watch lifecycle events instead of swallowing them silently * handlers.go: reject malformed JSON payloads in list-style WS handlers rather than silently falling through to broader list/search behavior * event_handlers_gitlab.go: remove dead gitlabRepoSlug helper + blank-identifier suppression * ci: re-trigger to clear flaky E2E shard 3 * fix(gitlab): address final review round — nil guards, store merge, logs, body validation - CheckMRWatch, UpdateReviewWatch, UpdateIssueWatch: nil guards for store/req - handlers: wsNewDiscussionNote rejects empty body - action_presets: Update reads raw stored row (no default freezing); Reset validates workspace_id - service_search.GetStats: log Warn per sub-call failure before zero - event_handlers_gitlab: log Release* dedup-row errors with context - web/store.ts: post-slice merge restores every GitLab sub-state field; extract buildStateOverrides helper - web/default-state.ts: add GitLab fields to defaultState + mergeInitialState via mergeGitLabFields helper - web/gitlab-api.ts: UpdateXxxWatchRequest now Omit workspace_id Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Kandev Agent <agent@kandev.dev> Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>
167 lines
6.3 KiB
Go
167 lines
6.3 KiB
Go
package orchestrator
|
|
|
|
import (
|
|
"context"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/kandev/kandev/internal/events"
|
|
"github.com/kandev/kandev/internal/events/bus"
|
|
"github.com/kandev/kandev/internal/gitlab"
|
|
)
|
|
|
|
// GitLabIssueTaskCreator creates a task from a GitLab issue + watch context.
|
|
// Mirrors github.IssueTaskCreator. Returns the created task id or an error.
|
|
type GitLabIssueTaskCreator interface {
|
|
CreateGitLabIssueTask(ctx context.Context, evt *gitlab.NewIssueEvent) (string, error)
|
|
}
|
|
|
|
// GitLabReviewTaskCreator creates a task from a GitLab MR + watch context.
|
|
type GitLabReviewTaskCreator interface {
|
|
CreateGitLabReviewTask(ctx context.Context, evt *gitlab.NewReviewMREvent) (string, error)
|
|
}
|
|
|
|
// SetGitLabIssueTaskCreator wires the issue→task creator used by the
|
|
// `gitlab.new_issue` handler. When nil, watches still fire but no tasks
|
|
// are auto-created (events are logged for observability).
|
|
func (s *Service) SetGitLabIssueTaskCreator(c GitLabIssueTaskCreator) {
|
|
s.gitlabIssueTaskCreator = c
|
|
}
|
|
|
|
// SetGitLabReviewTaskCreator wires the review→task creator.
|
|
func (s *Service) SetGitLabReviewTaskCreator(c GitLabReviewTaskCreator) {
|
|
s.gitlabReviewTaskCreator = c
|
|
}
|
|
|
|
// SetGitLabService is the entry point for wiring the GitLab service into the
|
|
// orchestrator so the event handlers can reserve dedup rows. Mirrors
|
|
// SetGitHubService / SetJiraService.
|
|
func (s *Service) SetGitLabService(svc *gitlab.Service) {
|
|
s.gitlabService = svc
|
|
}
|
|
|
|
// subscribeGitLabEvents wires bus subscriptions for the GitLab integration
|
|
// events. Idempotent — safe to call once per orchestrator boot.
|
|
func (s *Service) subscribeGitLabEvents() {
|
|
if s.eventBus == nil {
|
|
return
|
|
}
|
|
if _, err := s.eventBus.Subscribe(events.GitLabNewReviewMR, s.handleGitLabNewReviewMR); err != nil {
|
|
s.logger.Error("subscribe gitlab.new_mr_to_review", zap.Error(err))
|
|
}
|
|
if _, err := s.eventBus.Subscribe(events.GitLabNewIssue, s.handleGitLabNewIssue); err != nil {
|
|
s.logger.Error("subscribe gitlab.new_issue", zap.Error(err))
|
|
}
|
|
}
|
|
|
|
// handleGitLabNewReviewMR turns a new-MR-to-review event into a Kandev task.
|
|
// When no review-task creator is configured the event is logged and dropped
|
|
// (matches the GitHub flow when a workspace has no task creator wired).
|
|
func (s *Service) handleGitLabNewReviewMR(ctx context.Context, event *bus.Event) error {
|
|
evt, ok := event.Data.(*gitlab.NewReviewMREvent)
|
|
if !ok || evt == nil || evt.MR == nil {
|
|
return nil
|
|
}
|
|
s.logger.Info("new gitlab MR detected from review watch",
|
|
zap.String("review_watch_id", evt.ReviewWatchID),
|
|
zap.String("project", evt.MR.ProjectPath),
|
|
zap.Int("iid", evt.MR.IID))
|
|
if s.gitlabReviewTaskCreator == nil {
|
|
s.logger.Debug("gitlab review task creator not configured; skipping task creation")
|
|
return nil
|
|
}
|
|
go s.createGitLabReviewTask(context.Background(), evt)
|
|
return nil
|
|
}
|
|
|
|
// a different domain type (MR vs Issue); merging them would obscure the
|
|
// per-event publishing contract.
|
|
//
|
|
//nolint:dupl // structurally similar to createGitLabIssueTask but operates on
|
|
func (s *Service) createGitLabReviewTask(ctx context.Context, evt *gitlab.NewReviewMREvent) {
|
|
if s.gitlabService == nil {
|
|
s.logger.Warn("gitlab service not configured; cannot reserve dedup")
|
|
return
|
|
}
|
|
mr := evt.MR
|
|
claimed, err := s.gitlabService.ReserveReviewMRTask(ctx, evt.ReviewWatchID, mr.ProjectPath, mr.IID, mr.WebURL)
|
|
if err != nil || !claimed {
|
|
if err != nil {
|
|
s.logger.Warn("reserve gitlab review MR task", zap.Error(err))
|
|
}
|
|
return
|
|
}
|
|
taskID, err := s.gitlabReviewTaskCreator.CreateGitLabReviewTask(ctx, evt)
|
|
if err != nil {
|
|
s.logger.Warn("create gitlab review task", zap.Error(err))
|
|
if relErr := s.gitlabService.ReleaseReviewMRTask(ctx, evt.ReviewWatchID, mr.ProjectPath, mr.IID); relErr != nil {
|
|
s.logger.Warn("release gitlab review MR dedup row after task-create failure",
|
|
zap.String("review_watch_id", evt.ReviewWatchID),
|
|
zap.String("project", mr.ProjectPath),
|
|
zap.Int("iid", mr.IID),
|
|
zap.Error(relErr))
|
|
}
|
|
return
|
|
}
|
|
if err := s.gitlabService.AssignReviewMRTaskID(ctx, evt.ReviewWatchID, mr.ProjectPath, mr.IID, taskID); err != nil {
|
|
s.logger.Warn("assign gitlab review MR task id", zap.Error(err))
|
|
}
|
|
s.logger.Info("gitlab review MR task created",
|
|
zap.String("task_id", taskID),
|
|
zap.String("project", mr.ProjectPath),
|
|
zap.Int("iid", mr.IID))
|
|
}
|
|
|
|
// handleGitLabNewIssue mirrors handleGitLabNewReviewMR for issue events.
|
|
func (s *Service) handleGitLabNewIssue(ctx context.Context, event *bus.Event) error {
|
|
evt, ok := event.Data.(*gitlab.NewIssueEvent)
|
|
if !ok || evt == nil || evt.Issue == nil {
|
|
return nil
|
|
}
|
|
s.logger.Info("new gitlab issue detected from issue watch",
|
|
zap.String("issue_watch_id", evt.IssueWatchID),
|
|
zap.String("project", evt.Issue.ProjectPath),
|
|
zap.Int("iid", evt.Issue.IID))
|
|
if s.gitlabIssueTaskCreator == nil {
|
|
s.logger.Debug("gitlab issue task creator not configured; skipping task creation")
|
|
return nil
|
|
}
|
|
go s.createGitLabIssueTask(context.Background(), evt)
|
|
return nil
|
|
}
|
|
|
|
//nolint:dupl // see createGitLabReviewTask — same shape, different domain types.
|
|
func (s *Service) createGitLabIssueTask(ctx context.Context, evt *gitlab.NewIssueEvent) {
|
|
if s.gitlabService == nil {
|
|
s.logger.Warn("gitlab service not configured; cannot reserve dedup")
|
|
return
|
|
}
|
|
issue := evt.Issue
|
|
claimed, err := s.gitlabService.ReserveIssueWatchTask(ctx, evt.IssueWatchID, issue.ProjectPath, issue.IID, issue.WebURL)
|
|
if err != nil || !claimed {
|
|
if err != nil {
|
|
s.logger.Warn("reserve gitlab issue task", zap.Error(err))
|
|
}
|
|
return
|
|
}
|
|
taskID, err := s.gitlabIssueTaskCreator.CreateGitLabIssueTask(ctx, evt)
|
|
if err != nil {
|
|
s.logger.Warn("create gitlab issue task", zap.Error(err))
|
|
if relErr := s.gitlabService.ReleaseIssueWatchTask(ctx, evt.IssueWatchID, issue.ProjectPath, issue.IID); relErr != nil {
|
|
s.logger.Warn("release gitlab issue dedup row after task-create failure",
|
|
zap.String("issue_watch_id", evt.IssueWatchID),
|
|
zap.String("project", issue.ProjectPath),
|
|
zap.Int("iid", issue.IID),
|
|
zap.Error(relErr))
|
|
}
|
|
return
|
|
}
|
|
if err := s.gitlabService.AssignIssueWatchTaskID(ctx, evt.IssueWatchID, issue.ProjectPath, issue.IID, taskID); err != nil {
|
|
s.logger.Warn("assign gitlab issue task id", zap.Error(err))
|
|
}
|
|
s.logger.Info("gitlab issue task created",
|
|
zap.String("task_id", taskID),
|
|
zap.String("project", issue.ProjectPath),
|
|
zap.Int("iid", issue.IID))
|
|
}
|