feat: add CI/CD status integration to wt status (#84)

* feat: add CI/CD status to wt status --ci

Show pipeline status (pass/fail/pending) per branch in the status
dashboard. Uses gh CLI for GitHub repos and glab CLI for GitLab.
Displays colored indicators: ✓ (pass), ✗ (fail), ● (pending).

Opt-in via --ci flag to avoid slowing down the default status command
with network calls.

* fix: prefer check runs API over commit status for GitHub Actions

The commit status API returns "pending" when there are no statuses,
which is the common case for repos using GitHub Actions (which uses
check runs instead). Check the check runs API first and only fall
back to commit status for older CI integrations.

Author: timvw

README.md

@@ -22,6 +22,7 @@ Inspired by [haacked/dotfiles/tree-me](https://github.com/haacked/dotfiles/blob/
 - **Pre/post command hooks** — run custom scripts on create/checkout/remove (e.g. [launch AI assistants](docs/examples.md#ai-assistants-and-editors), [share build caches](docs/examples.md#shared-build-cache-across-worktrees), [assign dev server ports](docs/examples.md#deterministic-dev-server-port-per-worktree), [copy `.env`](docs/examples.md#copy-env-to-new-worktrees))
 - **Stale worktree detection** — find worktrees with deleted remote branches or inactive commits (`wt cleanup --stale`)
 - **Color-coded status output** — green (clean), red (dirty), yellow (ahead/behind), bold cyan (current); respects `NO_COLOR=1` and auto-strips colors when piped
+- **CI/CD status integration** — `wt status --ci` shows pipeline status (✓/✗/●) per branch via `gh` or `glab` CLI
 - **Per-repo `.wt.toml` config** — override global settings (strategy, hooks, etc.) on a per-repository basis
 - Shell integration with auto-cd functionality
 - Tab completion for Bash and Zsh
@@ -106,9 +107,10 @@ wt config path                    # print the config file path
 
 ```bash
 wt status                         # color-coded overview of all worktrees
+wt status --ci                    # include CI/CD pipeline status (requires gh or glab)
 ```
 
-Shows dirty/clean state, ahead/behind counts, and highlights the current worktree. Colors are automatically stripped when piping; set `NO_COLOR=1` to disable.
+Shows dirty/clean state, ahead/behind counts, and highlights the current worktree. With `--ci`, each branch shows ✓ (pass), ✗ (fail), or ● (pending) for its latest CI pipeline. Colors are automatically stripped when piping; set `NO_COLOR=1` to disable.
 
 ### Interactive Selection
 

main.go

@@ -98,6 +98,7 @@ func init() {
 	rootCmd.AddCommand(examplesCmd)
 	rootCmd.AddCommand(defaultCmd)
 	rootCmd.AddCommand(statusCmd)
+	statusCmd.Flags().BoolVar(&statusCI, "ci", false, "Show CI/CD pipeline status for each branch (requires gh or glab CLI)")
 	removeCmd.Flags().BoolVarP(&removeForce, "force", "f", false, "Force removal even if worktree has modifications")
 	cleanupCmd.Flags().BoolVar(&cleanupDryRun, "dry-run", false, "Preview what would be removed without making changes")
 	cleanupCmd.Flags().BoolVarP(&cleanupForce, "force", "f", false, "Remove all merged worktrees without confirmation")

status.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"os/exec"
@@ -19,8 +20,11 @@ type worktreeStatus struct {
 	Behind      int    `json:"behind"`
 	Current     bool   `json:"current"`
 	HasUpstream bool   `json:"has_upstream"`
+	CI          string `json:"ci,omitempty"`
 }
 
+var statusCI bool
+
 var statusCmd = &cobra.Command{
 	Use:   "status",
 	Short: "Show status dashboard of all worktrees",
@@ -29,6 +33,9 @@ var statusCmd = &cobra.Command{
 For each worktree, shows: path, branch, dirty/clean state, and
 ahead/behind counts relative to upstream.
 
+Use --ci to include CI/CD pipeline status for each branch
+(requires gh CLI for GitHub or glab CLI for GitLab).
+
 Use --format json for machine-readable output.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
 		entries, err := getWorktreeListPorcelain()
@@ -70,6 +77,14 @@ Use --format json for machine-readable output.`,
 			statuses = append(statuses, st)
 		}
 
+		// Fetch CI status if requested
+		if statusCI {
+			ciStatuses := getCIStatuses(statuses)
+			for i, ci := range ciStatuses {
+				statuses[i].CI = ci
+			}
+		}
+
 		if isJSONOutput() {
 			return emitJSONSuccess(cmd, map[string]any{"worktrees": statuses})
 		}
@@ -136,8 +151,13 @@ func formatStatusLineColor(st worktreeStatus, color bool) string {
 		tracking = "no upstream"
 	}
 
+	ci := ""
+	if st.CI != "" {
+		ci = " " + st.CI
+	}
+
 	if !color {
-		return fmt.Sprintf("%s %-14s %-30s %-7s %s", marker, st.Branch, st.Path, state, tracking)
+		return fmt.Sprintf("%s %-14s %-30s %-7s %s%s", marker, st.Branch, st.Path, state, tracking, ci)
 	}
 
 	// Apply colors
@@ -167,7 +187,25 @@ func formatStatusLineColor(st worktreeStatus, color bool) string {
 		tracking = aheadStr + " " + behindStr
 	}
 
-	return fmt.Sprintf("%s %-14s %-30s %-7s %s", marker, branch, st.Path, state, tracking)
+	if st.CI != "" {
+		ci = " " + formatCIColor(st.CI)
+	}
+
+	return fmt.Sprintf("%s %-14s %-30s %-7s %s%s", marker, branch, st.Path, state, tracking, ci)
+}
+
+// formatCIColor applies color to a CI status string.
+func formatCIColor(ci string) string {
+	switch ci {
+	case "pass":
+		return colorize("✓ CI", ansiGreen)
+	case "fail":
+		return colorize("✗ CI", ansiRed)
+	case "pending":
+		return colorize("● CI", ansiYellow)
+	default:
+		return colorize(ci, ansiDim)
+	}
 }
 
 // gitStatusPorcelain runs git status --porcelain in the given directory.
@@ -189,3 +227,156 @@ func gitRevListAheadBehind(dir string) (string, error) {
 	}
 	return string(output), nil
 }
+
+// getCIStatuses fetches CI check status for each worktree branch.
+// It detects whether the repo uses GitHub or GitLab and calls the
+// appropriate CLI tool. Returns a slice parallel to statuses.
+func getCIStatuses(statuses []worktreeStatus) []string {
+	results := make([]string, len(statuses))
+
+	remoteType := detectCIRemoteType()
+	if remoteType == RemoteUnknown {
+		return results
+	}
+
+	for i, st := range statuses {
+		if st.Branch == "" {
+			continue
+		}
+		results[i] = fetchCIStatus(st.Branch, remoteType)
+	}
+	return results
+}
+
+// detectCIRemoteType checks if gh or glab CLI is available and
+// whether the remote points to GitHub or GitLab.
+func detectCIRemoteType() RemoteType {
+	cmd := exec.Command("git", "remote", "get-url", "origin")
+	output, err := cmd.Output()
+	if err != nil {
+		return RemoteUnknown
+	}
+	url := strings.TrimSpace(string(output))
+
+	if strings.Contains(url, "github.com") {
+		if _, err := exec.LookPath("gh"); err == nil {
+			return RemoteGitHub
+		}
+	}
+	if strings.Contains(url, "gitlab") {
+		if _, err := exec.LookPath("glab"); err == nil {
+			return RemoteGitLab
+		}
+	}
+	return RemoteUnknown
+}
+
+// fetchCIStatus returns the CI status for a single branch.
+// Returns "pass", "fail", "pending", or "" if unavailable.
+func fetchCIStatus(branch string, remoteType RemoteType) string {
+	switch remoteType {
+	case RemoteGitHub:
+		return fetchGitHubCIStatus(branch)
+	case RemoteGitLab:
+		return fetchGitLabCIStatus(branch)
+	default:
+		return ""
+	}
+}
+
+// fetchGitHubCIStatus uses gh to get CI status for a branch.
+// Checks both the commit status API and the check runs API (GitHub Actions),
+// preferring check runs when the commit status API has no results.
+func fetchGitHubCIStatus(branch string) string {
+	// Try check runs first (GitHub Actions uses this)
+	checkResult := fetchGitHubCheckRuns(branch)
+	if checkResult != "" {
+		return checkResult
+	}
+
+	// Fall back to commit status API (older CI integrations)
+	cmd := exec.Command("gh", "api",
+		fmt.Sprintf("repos/{owner}/{repo}/commits/%s/status", branch),
+		"--jq", ".state")
+	output, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return normalizeGitHubState(strings.TrimSpace(string(output)))
+}
+
+// fetchGitHubCheckRuns uses gh to get check run conclusions for a branch.
+func fetchGitHubCheckRuns(branch string) string {
+	cmd := exec.Command("gh", "api",
+		fmt.Sprintf("repos/{owner}/{repo}/commits/%s/check-runs", branch),
+		"--jq", ".check_runs | map(.conclusion) | unique | join(\",\")")
+	output, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return normalizeGitHubCheckRuns(strings.TrimSpace(string(output)))
+}
+
+// normalizeGitHubState maps the GitHub combined status API state to our status.
+func normalizeGitHubState(state string) string {
+	switch state {
+	case "success":
+		return "pass"
+	case "failure", "error":
+		return "fail"
+	case "pending":
+		return "pending"
+	default:
+		return ""
+	}
+}
+
+// normalizeGitHubCheckRuns maps GitHub check run conclusions to our status.
+// Returns "" when there are no check runs at all.
+func normalizeGitHubCheckRuns(conclusions string) string {
+	if conclusions == "" {
+		return ""
+	}
+	for _, c := range strings.Split(conclusions, ",") {
+		switch c {
+		case "failure", "timed_out", "cancelled", "action_required":
+			return "fail"
+		case "null", "":
+			return "pending"
+		}
+	}
+	return "pass"
+}
+
+// fetchGitLabCIStatus uses glab to get the pipeline status for a branch.
+func fetchGitLabCIStatus(branch string) string {
+	cmd := exec.Command("glab", "ci", "status", "--branch", branch, "--output", "json")
+	output, err := cmd.Output()
+	if err != nil {
+		return ""
+	}
+	return normalizeGitLabState(strings.TrimSpace(string(output)))
+}
+
+// normalizeGitLabState maps glab ci status JSON output to our status.
+func normalizeGitLabState(jsonOutput string) string {
+	// glab ci status --output json returns {"status":"success",...}
+	var result struct {
+		Status string `json:"status"`
+	}
+	if err := json.Unmarshal([]byte(jsonOutput), &result); err != nil {
+		return ""
+	}
+	switch result.Status {
+	case "success":
+		return "pass"
+	case "failed":
+		return "fail"
+	case "running", "pending", "created", "waiting_for_resource", "preparing":
+		return "pending"
+	case "canceled", "skipped":
+		return ""
+	default:
+		return ""
+	}
+}