refactor(mrqueue): remove mrqueue package, use beads for MRs (gt-dqi)
Remove the mrqueue side-channel from gastown. The merge queue now uses
beads merge-request wisps exclusively, not parallel .beads/mq/*.json files.
Changes:
- Delete internal/mrqueue/ package (~830 lines removed)
- Move scoring logic to internal/refinery/score.go
- Update Refinery engineer to query beads via ReadyWithType("merge-request")
- Add MRInfo struct to replace mrqueue.MR
- Add ClaimMR/ReleaseMR methods using beads assignee field
- Update HandleMergeReady to not create duplicate queue entries
- Update gt refinery commands (claim, release, unclaimed) to use beads
- Stub out MQEventSource (no longer needed)
The Refinery now:
- Lists MRs via beads.ReadyWithType("merge-request")
- Claims via beads.Update(..., {Assignee: worker})
- Closes via beads.CloseWithReason("merged", mrID)
- Blocks on conflicts via beads.AddDependency(mrID, taskID)
Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
george
@@ -1,102 +1,42 @@
|
||||
package feed
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/steveyegge/gastown/internal/mrqueue"
|
||||
)
|
||||
|
||||
// MQEventSource reads MQ lifecycle events from mq_events.jsonl
|
||||
// MQEventSource was used to read MQ lifecycle events from mq_events.jsonl.
|
||||
// The mrqueue package has been removed, so this is now a no-op stub.
|
||||
// MR events can be observed via beads activity instead.
|
||||
type MQEventSource struct {
|
||||
file *os.File
|
||||
events chan Event
|
||||
cancel context.CancelFunc
|
||||
logPath string
|
||||
events chan Event
|
||||
cancel context.CancelFunc
|
||||
}
|
||||
|
||||
// NewMQEventSource creates a source that tails MQ events from a beads directory.
|
||||
// NewMQEventSource creates a stub source that produces no events.
|
||||
// The mrqueue event log is no longer written.
|
||||
func NewMQEventSource(beadsDir string) (*MQEventSource, error) {
|
||||
logPath := filepath.Join(beadsDir, "mq_events.jsonl")
|
||||
|
||||
// Create file if it doesn't exist
|
||||
if _, err := os.Stat(logPath); os.IsNotExist(err) {
|
||||
// Ensure directory exists
|
||||
if err := os.MkdirAll(filepath.Dir(logPath), 0755); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
// Create empty file
|
||||
f, err := os.Create(logPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_ = f.Close() //nolint:gosec // G104: best-effort close on file creation
|
||||
}
|
||||
|
||||
file, err := os.Open(logPath)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
|
||||
source := &MQEventSource{
|
||||
file: file,
|
||||
events: make(chan Event, 100),
|
||||
cancel: cancel,
|
||||
logPath: logPath,
|
||||
events: make(chan Event, 1),
|
||||
cancel: cancel,
|
||||
}
|
||||
|
||||
go source.tail(ctx)
|
||||
// Start a goroutine that just waits for cancellation
|
||||
go func() {
|
||||
<-ctx.Done()
|
||||
close(source.events)
|
||||
}()
|
||||
|
||||
return source, nil
|
||||
}
|
||||
|
||||
// NewMQEventSourceFromWorkDir creates an MQ event source by finding the beads directory.
|
||||
// NewMQEventSourceFromWorkDir creates an MQ event source (stub).
|
||||
func NewMQEventSourceFromWorkDir(workDir string) (*MQEventSource, error) {
|
||||
beadsDir, err := FindBeadsDir(workDir)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return NewMQEventSource(beadsDir)
|
||||
return NewMQEventSource("")
|
||||
}
|
||||
|
||||
// tail follows the MQ event log file and sends events.
|
||||
func (s *MQEventSource) tail(ctx context.Context) {
|
||||
defer close(s.events)
|
||||
|
||||
// Seek to end for live tailing
|
||||
_, _ = s.file.Seek(0, 2)
|
||||
|
||||
scanner := bufio.NewScanner(s.file)
|
||||
ticker := time.NewTicker(100 * time.Millisecond)
|
||||
defer ticker.Stop()
|
||||
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
if event := parseMQEventLine(line); event != nil {
|
||||
select {
|
||||
case s.events <- *event:
|
||||
default:
|
||||
// Drop event if channel full
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Events returns the event channel.
|
||||
// Events returns the event channel (always empty).
|
||||
func (s *MQEventSource) Events() <-chan Event {
|
||||
return s.events
|
||||
}
|
||||
@@ -104,86 +44,5 @@ func (s *MQEventSource) Events() <-chan Event {
|
||||
// Close stops the source.
|
||||
func (s *MQEventSource) Close() error {
|
||||
s.cancel()
|
||||
return s.file.Close()
|
||||
}
|
||||
|
||||
// parseMQEventLine parses a line from mq_events.jsonl into a feed Event.
|
||||
func parseMQEventLine(line string) *Event {
|
||||
if strings.TrimSpace(line) == "" {
|
||||
return nil
|
||||
}
|
||||
|
||||
var mqEvent mrqueue.Event
|
||||
if err := json.Unmarshal([]byte(line), &mqEvent); err != nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
// Convert MQ event to feed Event
|
||||
feedType := mapMQEventType(mqEvent.Type)
|
||||
message := formatMQEventMessage(mqEvent)
|
||||
|
||||
return &Event{
|
||||
Time: mqEvent.Timestamp,
|
||||
Type: feedType,
|
||||
Actor: "refinery",
|
||||
Target: mqEvent.MRID,
|
||||
Message: message,
|
||||
Rig: mqEvent.Rig,
|
||||
Role: "refinery",
|
||||
Raw: line,
|
||||
}
|
||||
}
|
||||
|
||||
// mapMQEventType maps MQ event types to feed event types.
|
||||
func mapMQEventType(mqType mrqueue.EventType) string {
|
||||
switch mqType {
|
||||
case mrqueue.EventMergeStarted:
|
||||
return "merge_started"
|
||||
case mrqueue.EventMerged:
|
||||
return "merged"
|
||||
case mrqueue.EventMergeFailed:
|
||||
return "merge_failed"
|
||||
case mrqueue.EventMergeSkipped:
|
||||
return "merge_skipped"
|
||||
default:
|
||||
return string(mqType)
|
||||
}
|
||||
}
|
||||
|
||||
// formatMQEventMessage creates a human-readable message for an MQ event.
|
||||
func formatMQEventMessage(e mrqueue.Event) string {
|
||||
branchInfo := e.Branch
|
||||
if e.Target != "" {
|
||||
branchInfo += " -> " + e.Target
|
||||
}
|
||||
|
||||
switch e.Type {
|
||||
case mrqueue.EventMergeStarted:
|
||||
return "Merge started: " + branchInfo
|
||||
case mrqueue.EventMerged:
|
||||
msg := "Merged: " + branchInfo
|
||||
if e.MergeCommit != "" {
|
||||
// Show short commit SHA
|
||||
sha := e.MergeCommit
|
||||
if len(sha) > 8 {
|
||||
sha = sha[:8]
|
||||
}
|
||||
msg += " (" + sha + ")"
|
||||
}
|
||||
return msg
|
||||
case mrqueue.EventMergeFailed:
|
||||
msg := "Merge failed: " + branchInfo
|
||||
if e.Reason != "" {
|
||||
msg += " - " + e.Reason
|
||||
}
|
||||
return msg
|
||||
case mrqueue.EventMergeSkipped:
|
||||
msg := "Merge skipped: " + branchInfo
|
||||
if e.Reason != "" {
|
||||
msg += " - " + e.Reason
|
||||
}
|
||||
return msg
|
||||
default:
|
||||
return string(e.Type) + ": " + branchInfo
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -1,144 +0,0 @@
|
||||
package feed
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/steveyegge/gastown/internal/mrqueue"
|
||||
)
|
||||
|
||||
func TestParseMQEventLine(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
event mrqueue.Event
|
||||
wantType string
|
||||
wantTarget string
|
||||
wantContains string // Substring in message
|
||||
}{
|
||||
{
|
||||
name: "merge_started",
|
||||
event: mrqueue.Event{
|
||||
Timestamp: time.Now(),
|
||||
Type: mrqueue.EventMergeStarted,
|
||||
MRID: "mr-123",
|
||||
Branch: "polecat/nux",
|
||||
Target: "main",
|
||||
Worker: "nux",
|
||||
Rig: "gastown",
|
||||
},
|
||||
wantType: "merge_started",
|
||||
wantTarget: "mr-123",
|
||||
wantContains: "Merge started",
|
||||
},
|
||||
{
|
||||
name: "merged",
|
||||
event: mrqueue.Event{
|
||||
Timestamp: time.Now(),
|
||||
Type: mrqueue.EventMerged,
|
||||
MRID: "mr-456",
|
||||
Branch: "polecat/toast",
|
||||
Target: "main",
|
||||
Worker: "toast",
|
||||
Rig: "gastown",
|
||||
MergeCommit: "abc123def456789",
|
||||
},
|
||||
wantType: "merged",
|
||||
wantTarget: "mr-456",
|
||||
wantContains: "abc123de", // Short SHA
|
||||
},
|
||||
{
|
||||
name: "merge_failed",
|
||||
event: mrqueue.Event{
|
||||
Timestamp: time.Now(),
|
||||
Type: mrqueue.EventMergeFailed,
|
||||
MRID: "mr-789",
|
||||
Branch: "polecat/capable",
|
||||
Target: "main",
|
||||
Worker: "capable",
|
||||
Rig: "gastown",
|
||||
Reason: "conflict in main.go",
|
||||
},
|
||||
wantType: "merge_failed",
|
||||
wantTarget: "mr-789",
|
||||
wantContains: "conflict in main.go",
|
||||
},
|
||||
{
|
||||
name: "merge_skipped",
|
||||
event: mrqueue.Event{
|
||||
Timestamp: time.Now(),
|
||||
Type: mrqueue.EventMergeSkipped,
|
||||
MRID: "mr-999",
|
||||
Branch: "polecat/skip",
|
||||
Target: "main",
|
||||
Reason: "already merged",
|
||||
},
|
||||
wantType: "merge_skipped",
|
||||
wantTarget: "mr-999",
|
||||
wantContains: "already merged",
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
// Marshal to JSON line
|
||||
data, err := json.Marshal(tt.event)
|
||||
if err != nil {
|
||||
t.Fatalf("Failed to marshal event: %v", err)
|
||||
}
|
||||
|
||||
// Parse the line
|
||||
result := parseMQEventLine(string(data))
|
||||
if result == nil {
|
||||
t.Fatal("parseMQEventLine returned nil")
|
||||
}
|
||||
|
||||
if result.Type != tt.wantType {
|
||||
t.Errorf("Type = %q, want %q", result.Type, tt.wantType)
|
||||
}
|
||||
|
||||
if result.Target != tt.wantTarget {
|
||||
t.Errorf("Target = %q, want %q", result.Target, tt.wantTarget)
|
||||
}
|
||||
|
||||
if tt.wantContains != "" && !contains(result.Message, tt.wantContains) {
|
||||
t.Errorf("Message = %q, want to contain %q", result.Message, tt.wantContains)
|
||||
}
|
||||
|
||||
// Actor should be refinery
|
||||
if result.Actor != "refinery" {
|
||||
t.Errorf("Actor = %q, want %q", result.Actor, "refinery")
|
||||
}
|
||||
|
||||
if result.Role != "refinery" {
|
||||
t.Errorf("Role = %q, want %q", result.Role, "refinery")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseMQEventLineEmpty(t *testing.T) {
|
||||
result := parseMQEventLine("")
|
||||
if result != nil {
|
||||
t.Error("Expected nil for empty line")
|
||||
}
|
||||
|
||||
result = parseMQEventLine(" ")
|
||||
if result != nil {
|
||||
t.Error("Expected nil for whitespace-only line")
|
||||
}
|
||||
|
||||
result = parseMQEventLine("not valid json")
|
||||
if result != nil {
|
||||
t.Error("Expected nil for invalid JSON")
|
||||
}
|
||||
}
|
||||
|
||||
func contains(s, substr string) bool {
|
||||
for i := 0; i <= len(s)-len(substr); i++ {
|
||||
if s[i:i+len(substr)] == substr {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
Reference in New Issue
Block a user