From 3acb0e9c121f61c304dc09ed8d2db60c28b56da7 Mon Sep 17 00:00:00 2001 From: Steve Yegge Date: Thu, 18 Dec 2025 20:10:40 -0800 Subject: [PATCH 1/2] feat: implement gt mq reject command for manual MR rejection MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add gt mq command group with reject subcommand - Add FindMR method to locate MRs by ID or branch - Add RejectMR method to reject MRs with reason - Add notifyWorkerRejected for optional mail notification - Add tests for rejection state transitions Closes gt-svi.5 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- internal/cmd/mq.go | 79 +++++++++++++++++++++++++++++++ internal/refinery/manager.go | 82 +++++++++++++++++++++++++++++++++ internal/refinery/types_test.go | 45 ++++++++++++++++++ 3 files changed, 206 insertions(+) create mode 100644 internal/cmd/mq.go diff --git a/internal/cmd/mq.go b/internal/cmd/mq.go new file mode 100644 index 00000000..34b15f5f --- /dev/null +++ b/internal/cmd/mq.go @@ -0,0 +1,79 @@ +package cmd + +import ( + "fmt" + + "github.com/spf13/cobra" + "github.com/steveyegge/gastown/internal/style" +) + +// MQ command flags +var ( + mqRejectReason string + mqRejectNotify bool +) + +var mqCmd = &cobra.Command{ + Use: "mq", + Short: "Merge queue operations", + Long: `Manage the merge queue for a rig. + +The merge queue tracks work branches from polecats waiting to be merged. +Use these commands to view, submit, and manage merge requests.`, +} + +var mqRejectCmd = &cobra.Command{ + Use: "reject ", + Short: "Reject a merge request", + Long: `Manually reject a merge request. + +This closes the MR with a 'rejected' status without merging. +The source issue is NOT closed (work is not done). + +Examples: + gt mq reject gastown polecat/Nux/gt-xyz --reason "Does not meet requirements" + gt mq reject gastown mr-Nux-12345 --reason "Superseded by other work" --notify`, + Args: cobra.ExactArgs(2), + RunE: runMQReject, +} + +func init() { + // Reject flags + mqRejectCmd.Flags().StringVarP(&mqRejectReason, "reason", "r", "", "Reason for rejection (required)") + mqRejectCmd.Flags().BoolVar(&mqRejectNotify, "notify", false, "Send mail notification to worker") + mqRejectCmd.MarkFlagRequired("reason") + + // Add subcommands + mqCmd.AddCommand(mqRejectCmd) + + rootCmd.AddCommand(mqCmd) +} + +func runMQReject(cmd *cobra.Command, args []string) error { + rigName := args[0] + mrIDOrBranch := args[1] + + mgr, _, err := getRefineryManager(rigName) + if err != nil { + return err + } + + result, err := mgr.RejectMR(mrIDOrBranch, mqRejectReason, mqRejectNotify) + if err != nil { + return fmt.Errorf("rejecting MR: %w", err) + } + + fmt.Printf("%s Rejected: %s\n", style.Bold.Render("✗"), result.Branch) + fmt.Printf(" Worker: %s\n", result.Worker) + fmt.Printf(" Reason: %s\n", mqRejectReason) + + if result.IssueID != "" { + fmt.Printf(" Issue: %s %s\n", result.IssueID, style.Dim.Render("(not closed - work not done)")) + } + + if mqRejectNotify { + fmt.Printf(" %s\n", style.Dim.Render("Worker notified via mail")) + } + + return nil +} diff --git a/internal/refinery/manager.go b/internal/refinery/manager.go index c8ad3971..61c11c47 100644 --- a/internal/refinery/manager.go +++ b/internal/refinery/manager.go @@ -551,6 +551,88 @@ Thank you for your contribution!`, router.Send(msg) } +// Common errors for MR operations +var ( + ErrMRNotFound = errors.New("merge request not found") +) + +// FindMR finds a merge request by ID or branch name. +// Returns nil if not found. +func (m *Manager) FindMR(idOrBranch string) (*MergeRequest, error) { + queue, err := m.Queue() + if err != nil { + return nil, err + } + + for _, item := range queue { + // Match by ID + if item.MR.ID == idOrBranch { + return item.MR, nil + } + // Match by branch name (with or without polecat/ prefix) + if item.MR.Branch == idOrBranch { + return item.MR, nil + } + if "polecat/"+idOrBranch == item.MR.Branch { + return item.MR, nil + } + // Match by worker name (partial match for convenience) + if strings.Contains(item.MR.ID, idOrBranch) { + return item.MR, nil + } + } + + return nil, ErrMRNotFound +} + +// RejectMR manually rejects a merge request. +// It closes the MR with rejected status and optionally notifies the worker. +// Returns the rejected MR for display purposes. +func (m *Manager) RejectMR(idOrBranch string, reason string, notify bool) (*MergeRequest, error) { + mr, err := m.FindMR(idOrBranch) + if err != nil { + return nil, err + } + + // Verify MR is open or in_progress (can't reject already closed) + if mr.IsClosed() { + return nil, fmt.Errorf("%w: MR is already closed with reason: %s", ErrClosedImmutable, mr.CloseReason) + } + + // Close with rejected reason + if err := mr.Close(CloseReasonRejected); err != nil { + return nil, fmt.Errorf("failed to close MR: %w", err) + } + mr.Error = reason + + // Optionally notify worker + if notify { + m.notifyWorkerRejected(mr, reason) + } + + return mr, nil +} + +// notifyWorkerRejected sends a rejection notification to a polecat. +func (m *Manager) notifyWorkerRejected(mr *MergeRequest, reason string) { + router := mail.NewRouter(m.workDir) + msg := &mail.Message{ + From: fmt.Sprintf("%s/refinery", m.rig.Name), + To: fmt.Sprintf("%s/%s", m.rig.Name, mr.Worker), + Subject: "Merge request rejected", + Body: fmt.Sprintf(`Your merge request has been rejected. + +Branch: %s +Issue: %s +Reason: %s + +Please review the feedback and address the issues before resubmitting.`, + mr.Branch, mr.IssueID, reason), + Priority: mail.PriorityNormal, + } + router.Send(msg) +} + // findTownRoot walks up directories to find the town root. func findTownRoot(startPath string) string { path := startPath diff --git a/internal/refinery/types_test.go b/internal/refinery/types_test.go index 06b17a48..c49282f7 100644 --- a/internal/refinery/types_test.go +++ b/internal/refinery/types_test.go @@ -255,3 +255,48 @@ func TestMergeRequest_StatusChecks(t *testing.T) { }) } } + +func TestMergeRequest_Rejection(t *testing.T) { + t.Run("reject from open succeeds", func(t *testing.T) { + mr := &MergeRequest{Status: MROpen} + err := mr.Close(CloseReasonRejected) + if err != nil { + t.Errorf("Close(rejected) unexpected error: %v", err) + } + if mr.Status != MRClosed { + t.Errorf("Close(rejected) status = %s, want %s", mr.Status, MRClosed) + } + if mr.CloseReason != CloseReasonRejected { + t.Errorf("Close(rejected) closeReason = %s, want %s", mr.CloseReason, CloseReasonRejected) + } + }) + + t.Run("reject from in_progress succeeds", func(t *testing.T) { + mr := &MergeRequest{Status: MRInProgress} + err := mr.Close(CloseReasonRejected) + if err != nil { + t.Errorf("Close(rejected) unexpected error: %v", err) + } + if mr.Status != MRClosed { + t.Errorf("Close(rejected) status = %s, want %s", mr.Status, MRClosed) + } + if mr.CloseReason != CloseReasonRejected { + t.Errorf("Close(rejected) closeReason = %s, want %s", mr.CloseReason, CloseReasonRejected) + } + }) + + t.Run("reject from closed fails", func(t *testing.T) { + mr := &MergeRequest{Status: MRClosed, CloseReason: CloseReasonMerged} + err := mr.Close(CloseReasonRejected) + if err == nil { + t.Error("Close(rejected) expected error, got nil") + } + if !errors.Is(err, ErrClosedImmutable) { + t.Errorf("Close(rejected) error = %v, want %v", err, ErrClosedImmutable) + } + // CloseReason should not change + if mr.CloseReason != CloseReasonMerged { + t.Errorf("Close(rejected) closeReason changed from %s to %s", CloseReasonMerged, mr.CloseReason) + } + }) +} From dea935f647157583a2fafed79143c48885c7c615 Mon Sep 17 00:00:00 2001 From: Steve Yegge Date: Thu, 18 Dec 2025 20:16:10 -0800 Subject: [PATCH 2/2] feat: implement gt mq list command for merge queue display MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Add gt mq list command with table output - Support --ready flag to show only unblocked MRs - Support --status, --worker, --epic filtering - Support --json output format - Parse MR fields from beads issues for display - Show blocking info for blocked MRs Closes gt-svi.2 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 --- internal/cmd/mq.go | 234 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 234 insertions(+) diff --git a/internal/cmd/mq.go b/internal/cmd/mq.go index 34b15f5f..5b7d7dac 100644 --- a/internal/cmd/mq.go +++ b/internal/cmd/mq.go @@ -1,9 +1,14 @@ package cmd import ( + "encoding/json" "fmt" + "os" + "strings" + "time" "github.com/spf13/cobra" + "github.com/steveyegge/gastown/internal/beads" "github.com/steveyegge/gastown/internal/style" ) @@ -11,6 +16,13 @@ import ( var ( mqRejectReason string mqRejectNotify bool + + // List command flags + mqListReady bool + mqListStatus string + mqListWorker string + mqListEpic string + mqListJSON bool ) var mqCmd = &cobra.Command{ @@ -22,6 +34,29 @@ The merge queue tracks work branches from polecats waiting to be merged. Use these commands to view, submit, and manage merge requests.`, } +var mqListCmd = &cobra.Command{ + Use: "list ", + Short: "Show the merge queue", + Long: `Show the merge queue for a rig. + +Lists all pending merge requests waiting to be processed. + +Output format: + ID STATUS PRIORITY BRANCH WORKER AGE + gt-mr-001 ready P0 polecat/Nux/gt-xyz Nux 5m + gt-mr-002 in_progress P1 polecat/Toast/gt-abc Toast 12m + gt-mr-003 blocked P1 polecat/Capable/gt-def Capable 8m + (waiting on gt-mr-001) + +Examples: + gt mq list gastown + gt mq list gastown --ready + gt mq list gastown --status=open + gt mq list gastown --worker=Nux`, + Args: cobra.ExactArgs(1), + RunE: runMQList, +} + var mqRejectCmd = &cobra.Command{ Use: "reject ", Short: "Reject a merge request", @@ -38,17 +73,216 @@ Examples: } func init() { + // List flags + mqListCmd.Flags().BoolVar(&mqListReady, "ready", false, "Show only ready-to-merge (no blockers)") + mqListCmd.Flags().StringVar(&mqListStatus, "status", "", "Filter by status (open, in_progress, closed)") + mqListCmd.Flags().StringVar(&mqListWorker, "worker", "", "Filter by worker name") + mqListCmd.Flags().StringVar(&mqListEpic, "epic", "", "Show MRs targeting integration/") + mqListCmd.Flags().BoolVar(&mqListJSON, "json", false, "Output as JSON") + // Reject flags mqRejectCmd.Flags().StringVarP(&mqRejectReason, "reason", "r", "", "Reason for rejection (required)") mqRejectCmd.Flags().BoolVar(&mqRejectNotify, "notify", false, "Send mail notification to worker") mqRejectCmd.MarkFlagRequired("reason") // Add subcommands + mqCmd.AddCommand(mqListCmd) mqCmd.AddCommand(mqRejectCmd) rootCmd.AddCommand(mqCmd) } +func runMQList(cmd *cobra.Command, args []string) error { + rigName := args[0] + + _, r, err := getRefineryManager(rigName) + if err != nil { + return err + } + + // Create beads wrapper for the rig + b := beads.New(r.Path) + + // Build list options - query for merge-request type + opts := beads.ListOptions{ + Type: "merge-request", + } + + // Apply status filter if specified + if mqListStatus != "" { + opts.Status = mqListStatus + } else if !mqListReady { + // Default to open if not showing ready + opts.Status = "open" + } + + var issues []*beads.Issue + + if mqListReady { + // Use ready query which filters by no blockers + allReady, err := b.Ready() + if err != nil { + return fmt.Errorf("querying ready MRs: %w", err) + } + // Filter to only merge-request type + for _, issue := range allReady { + if issue.Type == "merge-request" { + issues = append(issues, issue) + } + } + } else { + issues, err = b.List(opts) + if err != nil { + return fmt.Errorf("querying merge queue: %w", err) + } + } + + // Apply additional filters + var filtered []*beads.Issue + for _, issue := range issues { + // Parse MR fields + fields := beads.ParseMRFields(issue) + + // Filter by worker + if mqListWorker != "" { + worker := "" + if fields != nil { + worker = fields.Worker + } + if !strings.EqualFold(worker, mqListWorker) { + continue + } + } + + // Filter by epic (target branch) + if mqListEpic != "" { + target := "" + if fields != nil { + target = fields.Target + } + expectedTarget := "integration/" + mqListEpic + if target != expectedTarget { + continue + } + } + + filtered = append(filtered, issue) + } + + // JSON output + if mqListJSON { + return outputJSON(filtered) + } + + // Human-readable output + fmt.Printf("%s Merge queue for '%s':\n\n", style.Bold.Render("📋"), rigName) + + if len(filtered) == 0 { + fmt.Printf(" %s\n", style.Dim.Render("(empty)")) + return nil + } + + // Print header + fmt.Printf(" %-12s %-12s %-8s %-30s %-10s %s\n", + "ID", "STATUS", "PRIORITY", "BRANCH", "WORKER", "AGE") + fmt.Printf(" %s\n", strings.Repeat("-", 90)) + + // Print each MR + for _, issue := range filtered { + fields := beads.ParseMRFields(issue) + + // Determine display status + displayStatus := issue.Status + if issue.Status == "open" { + if len(issue.BlockedBy) > 0 || issue.BlockedByCount > 0 { + displayStatus = "blocked" + } else { + displayStatus = "ready" + } + } + + // Format status with styling + styledStatus := displayStatus + switch displayStatus { + case "ready": + styledStatus = style.Bold.Render("ready") + case "in_progress": + styledStatus = style.Bold.Render("in_progress") + case "blocked": + styledStatus = style.Dim.Render("blocked") + case "closed": + styledStatus = style.Dim.Render("closed") + } + + // Get MR fields + branch := "" + worker := "" + if fields != nil { + branch = fields.Branch + worker = fields.Worker + } + + // Truncate branch if too long + if len(branch) > 30 { + branch = branch[:27] + "..." + } + + // Format priority + priority := fmt.Sprintf("P%d", issue.Priority) + + // Calculate age + age := formatMRAge(issue.CreatedAt) + + // Truncate ID if needed + displayID := issue.ID + if len(displayID) > 12 { + displayID = displayID[:12] + } + + fmt.Printf(" %-12s %-12s %-8s %-30s %-10s %s\n", + displayID, styledStatus, priority, branch, worker, style.Dim.Render(age)) + + // Show blocking info if blocked + if displayStatus == "blocked" && len(issue.BlockedBy) > 0 { + fmt.Printf(" %s\n", style.Dim.Render(fmt.Sprintf(" (waiting on %s)", issue.BlockedBy[0]))) + } + } + + return nil +} + +// formatMRAge formats the age of an MR from its created_at timestamp. +func formatMRAge(createdAt string) string { + t, err := time.Parse(time.RFC3339, createdAt) + if err != nil { + // Try other formats + t, err = time.Parse("2006-01-02T15:04:05Z", createdAt) + if err != nil { + return "?" + } + } + + d := time.Since(t) + + if d < time.Minute { + return fmt.Sprintf("%ds", int(d.Seconds())) + } + if d < time.Hour { + return fmt.Sprintf("%dm", int(d.Minutes())) + } + if d < 24*time.Hour { + return fmt.Sprintf("%dh", int(d.Hours())) + } + return fmt.Sprintf("%dd", int(d.Hours()/24)) +} + +// outputJSON outputs data as JSON. +func outputJSON(data interface{}) error { + enc := json.NewEncoder(os.Stdout) + enc.SetIndent("", " ") + return enc.Encode(data) +} + func runMQReject(cmd *cobra.Command, args []string) error { rigName := args[0] mrIDOrBranch := args[1]