Add table view for mq status

Co-authored-by: Andrew <andrewxhill@gmail.com>

Author: andrewxhill-ai

internal/app/app_test.go

@@ -1760,6 +1760,37 @@ func TestStatusJSONReportsQueuedWork(t *testing.T) {
 	}
 }
 
+func TestStatusTableReportsHumanQueueSummary(t *testing.T) {
+	repoRoot, _ := createTestRepoWithRemote(t)
+	initRepoForWorker(t, repoRoot)
+
+	featurePath := filepath.Join(t.TempDir(), "feature-status-table")
+	runTestCommand(t, repoRoot, "git", "worktree", "add", "-b", "feature/status-table", featurePath)
+	writeFileAndCommit(t, featurePath, "status-table.txt", "status table\n", "feature status table")
+	submitBranch(t, featurePath)
+	queuePublish(t, repoRoot)
+
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+	if err := runCLI([]string{"status", "--repo", repoRoot, "--table", "--events", "2"}, newStepPrinter(&stdout), &stderr); err != nil {
+		t.Fatalf("runCLI returned error: %v", err)
+	}
+
+	output := stdout.String()
+	if !strings.Contains(output, "TYPE") || !strings.Contains(output, "STATUS") || !strings.Contains(output, "BRANCH") {
+		t.Fatalf("expected table headers, got %q", output)
+	}
+	if !strings.Contains(output, "publish") || !strings.Contains(output, "submit") {
+		t.Fatalf("expected publish and submit rows, got %q", output)
+	}
+	if !strings.Contains(output, "feature/status-table") {
+		t.Fatalf("expected feature branch in table, got %q", output)
+	}
+	if !strings.Contains(output, "Counts: queued_submissions=") {
+		t.Fatalf("expected compact counts summary, got %q", output)
+	}
+}
+
 func TestStatusUsesDurableRepoRecordWhenConfigDrifts(t *testing.T) {
 	repoRoot, _ := createTestRepoWithRemote(t)
 	initRepoForWorker(t, repoRoot)

internal/app/completion.go

@@ -94,7 +94,7 @@ _mainline_completions()
       COMPREPLY=( $(compgen -W "--repo --branch --sha --worktree --requested-by --priority --allow-newer-head --json --check --check-only --queue-only --wait --for --timeout --poll-interval" -- "$cur") )
       ;;
     status)
-      COMPREPLY=( $(compgen -W "--repo --json --events" -- "$cur") )
+      COMPREPLY=( $(compgen -W "--repo --json --table --events" -- "$cur") )
       ;;
     next)
       COMPREPLY=( $(compgen -W "commit push --repo --json --timeout --poll-interval" -- "$cur") )
@@ -233,7 +233,7 @@ _mainline() {
       return
       ;;
     status)
-      _arguments '--repo[repository path]:path:_files -/' '--json[json output]' '--events[number of recent events]:count:'
+      _arguments '--repo[repository path]:path:_files -/' '--json[json output]' '--table[compact human-readable table output]' '--events[number of recent events]:count:'
       return
       ;;
     confidence)
@@ -365,6 +365,8 @@ complete -c mainline -n "__fish_seen_subcommand_from watch" -l max-cycles
 complete -c mq -n "__fish_seen_subcommand_from watch" -l max-cycles
 complete -c mainline -n "__fish_seen_subcommand_from status" -l events
 complete -c mq -n "__fish_seen_subcommand_from status" -l events
+complete -c mainline -n "__fish_seen_subcommand_from status" -l table
+complete -c mq -n "__fish_seen_subcommand_from status" -l table
 complete -c mainline -n "__fish_seen_subcommand_from confidence" -l json
 complete -c mq -n "__fish_seen_subcommand_from confidence" -l json
 complete -c mainline -n "__fish_seen_subcommand_from confidence" -l events

internal/app/status.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"os"
 	"strings"
+	"text/tabwriter"
 	"time"
 
 	"github.com/recallnet/mainline/internal/domain"
@@ -187,10 +188,12 @@ Flags:
 
 	var repoPath string
 	var asJSON bool
+	var asTable bool
 	var limit int
 
 	fs.StringVar(&repoPath, "repo", ".", "repository path")
 	fs.BoolVar(&asJSON, "json", false, "output json")
+	fs.BoolVar(&asTable, "table", false, "render a compact human-readable table")
 	fs.IntVar(&limit, "events", 5, "number of recent events to show")
 
 	if err := fs.Parse(args); err != nil {
@@ -207,6 +210,9 @@ Flags:
 		encoder.SetIndent("", "  ")
 		return encoder.Encode(result)
 	}
+	if asTable {
+		return renderStatusTable(stdout, result)
+	}
 
 	return renderStatus(stdout, result)
 }
@@ -450,6 +456,150 @@ func renderStatus(stdout *stepPrinter, result statusResult) error {
 	return nil
 }
 
+func renderStatusTable(stdout *stepPrinter, result statusResult) error {
+	stdout.Section("Queue")
+	stdout.Line("Repo: %s", result.RepositoryRoot)
+	stdout.Line("State: %s", result.QueueSummary.Headline)
+	if result.ProtectedBranchSHA != "" {
+		stdout.Line("Protected: %s @ %s", result.ProtectedBranch, shortenSHA(result.ProtectedBranchSHA))
+	} else {
+		stdout.Line("Protected: %s", result.ProtectedBranch)
+	}
+	if result.ProtectedUpstream.HasUpstream {
+		stdout.Line("Upstream: %s (ahead %d, behind %d)", result.ProtectedUpstream.Upstream, result.ProtectedUpstream.AheadCount, result.ProtectedUpstream.BehindCount)
+	}
+	if result.ProtectedWorktreeActivity != nil {
+		stdout.Line("Activity: %s", result.ProtectedWorktreeActivity.Summary)
+	}
+
+	tw := tabwriter.NewWriter(stdout.Raw(), 0, 0, 2, ' ', 0)
+	_, _ = fmt.Fprintln(tw, "")
+	_, _ = fmt.Fprintln(tw, "TYPE\tID\tSTATUS\tSTAGE\tBRANCH\tTARGET")
+
+	rows := statusTableRows(result)
+	if len(rows) == 0 {
+		_, _ = fmt.Fprintln(tw, "-\t-\tidle\t-\t-\t-")
+	} else {
+		for _, row := range rows {
+			_, _ = fmt.Fprintf(tw, "%s\t%s\t%s\t%s\t%s\t%s\n", row[0], row[1], row[2], row[3], row[4], row[5])
+		}
+	}
+	if err := tw.Flush(); err != nil {
+		return err
+	}
+
+	stdout.Line("")
+	stdout.Line("Counts: queued_submissions=%d running_submissions=%d blocked_submissions=%d queued_publishes=%d running_publishes=%d",
+		result.Counts.QueuedSubmissions,
+		result.Counts.RunningSubmissions,
+		result.Counts.BlockSubmissions,
+		result.Counts.QueuedPublishes,
+		result.Counts.RunningPublishes,
+	)
+	if len(result.Alerts) > 0 {
+		for _, alert := range result.Alerts {
+			stdout.Line("Alert: %s", alert)
+		}
+	}
+	return nil
+}
+
+func statusTableRows(result statusResult) [][]string {
+	rows := make([][]string, 0, len(result.ActivePublishes)+len(result.ActiveSubmissions)+2)
+	for _, request := range result.ActivePublishes {
+		rows = append(rows, []string{
+			"publish",
+			fmt.Sprintf("%d", request.ID),
+			string(request.Status),
+			emptyDash(request.ActiveStage),
+			"-",
+			shortenSHA(request.TargetSHA),
+		})
+	}
+	for _, submission := range result.ActiveSubmissions {
+		rows = append(rows, []string{
+			"submit",
+			fmt.Sprintf("%d", submission.ID),
+			string(submission.Status),
+			submissionStage(submission),
+			submissionDisplayRef(submission.integrationSubmission()),
+			shortenSHA(nonEmpty(submission.ProtectedTipSHA, submission.SourceSHA)),
+		})
+	}
+	if result.LatestSubmission != nil && !containsStatusRow(rows, "submit", result.LatestSubmission.ID) {
+		rows = append(rows, []string{
+			"submit",
+			fmt.Sprintf("%d", result.LatestSubmission.ID),
+			string(result.LatestSubmission.Status),
+			submissionStage(*result.LatestSubmission),
+			submissionDisplayRef(result.LatestSubmission.integrationSubmission()),
+			shortenSHA(nonEmpty(result.LatestSubmission.ProtectedTipSHA, result.LatestSubmission.SourceSHA)),
+		})
+	}
+	if result.LatestPublish != nil && !containsStatusRow(rows, "publish", result.LatestPublish.ID) {
+		rows = append(rows, []string{
+			"publish",
+			fmt.Sprintf("%d", result.LatestPublish.ID),
+			string(result.LatestPublish.Status),
+			emptyDash(result.LatestPublish.ActiveStage),
+			"-",
+			shortenSHA(result.LatestPublish.TargetSHA),
+		})
+	}
+	return rows
+}
+
+func containsStatusRow(rows [][]string, rowType string, id int64) bool {
+	needle := fmt.Sprintf("%d", id)
+	for _, row := range rows {
+		if len(row) >= 2 && row[0] == rowType && row[1] == needle {
+			return true
+		}
+	}
+	return false
+}
+
+func submissionStage(submission statusSubmission) string {
+	switch submission.Status {
+	case domain.SubmissionStatusQueued:
+		return "queued"
+	case domain.SubmissionStatusRunning:
+		return "integrating"
+	case domain.SubmissionStatusBlocked:
+		return "blocked"
+	case domain.SubmissionStatusSucceeded:
+		if submission.Outcome != "" {
+			return string(submission.Outcome)
+		}
+		return "integrated"
+	default:
+		if submission.Outcome != "" {
+			return string(submission.Outcome)
+		}
+		return "-"
+	}
+}
+
+func shortenSHA(sha string) string {
+	trimmed := strings.TrimSpace(sha)
+	if len(trimmed) > 8 {
+		return trimmed[:8]
+	}
+	if trimmed == "" {
+		return "-"
+	}
+	return trimmed
+}
+
+func nonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return value
+		}
+	}
+	return ""
+}
+
 func buildStatusRebaseGuidance(cfg policy.File, comparison git.BranchComparison, protectedStatus git.BranchStatus, repoPath string, branch string) *statusRebaseGuidance {
 	guidance := &statusRebaseGuidance{
 		NeedsRebase:          comparison.BehindCount > 0,