Turn overview into an inventory across local and server

overview showed dirty and ahead/behind per project, which git can do on
its own. mgsh is the only thing that sees both the local base directory
and the ssh server, and joining those answers the questions git cannot:
which projects were never pushed to the server (candidates for `init`),
and which exist there but not on this machine (candidates for `clone`).
Both lists are printed after the summary. An unreachable server is
reported as such, rather than as "everything is missing".

Each row also names the machine that made the last commit and how long
ago. That costs nothing: `push` has always stamped "[user@host]" into
the commit message, and nothing ever read it back. On a setup spanning
several machines it is usually the piece one actually wanted. Rows also
show which mirror targets the repository has a remote for, which is
local git config and therefore free.

The walk is now concurrent and cheaper per project: `git status
--porcelain=v2 --branch` yields branch, upstream, ahead/behind and dirty
in one subprocess where three were used before.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

overview_test.go

@@ -0,0 +1,152 @@
+package main
+
+// overview_test.go — the inventory view: what mgsh knows that plain git cannot.
+
+import (
+	"errors"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestReadStatusParsesPorcelainV2 covers the single `git status` call that
+// replaced three separate ones: branch, upstream, ahead/behind and dirty all
+// come out of its header.
+func TestReadStatusParsesPorcelainV2(t *testing.T) {
+	dir := t.TempDir()
+	bare := filepath.Join(t.TempDir(), "o.git")
+	mustGit(t, "", "init", "--bare", "-q", bare)
+	mustGit(t, dir, "init", "-q")
+	mustGit(t, dir, "config", "user.name", "t")
+	mustGit(t, dir, "config", "user.email", "t@e")
+	mustGit(t, dir, "commit", "-q", "--allow-empty", "-m", "[mike@laptop] work")
+	mustGit(t, dir, "remote", "add", "origin", bare)
+	mustGit(t, dir, "push", "-q", "-u", "origin", "HEAD")
+
+	var s projStatus
+	readStatus(&s, dir)
+	if !s.hasUpstream || s.ahead != 0 || s.behind != 0 || s.dirty {
+		t.Errorf("clean synced repo = %+v", s)
+	}
+	if s.branch == "" || s.branch == "-" {
+		t.Errorf("branch not read: %q", s.branch)
+	}
+
+	// one unstaged file and one unpushed commit
+	if err := os.WriteFile(filepath.Join(dir, "x"), []byte("x"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	mustGit(t, dir, "commit", "-q", "--allow-empty", "-m", "[mike@desktop] more")
+
+	s = projStatus{}
+	readStatus(&s, dir)
+	if !s.dirty {
+		t.Error("untracked file did not register as dirty")
+	}
+	if s.ahead != 1 {
+		t.Errorf("ahead = %d, want 1", s.ahead)
+	}
+
+	// and the host stamp `push` writes is picked up
+	var l projStatus
+	readLastCommit(&l, dir)
+	if l.lastHost != "desktop" {
+		t.Errorf("lastHost = %q, want desktop", l.lastHost)
+	}
+	if l.lastWhen.IsZero() {
+		t.Error("lastWhen not read")
+	}
+}
+
+// TestCommitHostRe: only mgsh's own "[user@host]" stamp counts.
+func TestCommitHostRe(t *testing.T) {
+	cases := map[string]string{
+		"[mike@laptop] fixed a thing": "laptop",
+		"[mike@build-01] ":            "build-01",
+		"[@host] no user":             "host",
+		"fixed a thing":               "",
+		"[not a stamp] text":          "",
+		"see [a@b] mid-line":          "",
+	}
+	for subj, want := range cases {
+		got := ""
+		if m := commitHostRe.FindStringSubmatch(subj); m != nil {
+			got = m[1]
+		}
+		if got != want {
+			t.Errorf("host of %q = %q, want %q", subj, got, want)
+		}
+	}
+}
+
+// TestReportInventoryUnreachableServer: when the server cannot be listed, the
+// overview must say so rather than claim every project is missing there.
+func TestReportInventoryUnreachableServer(t *testing.T) {
+	out := captureStdout(t, func() {
+		reportInventory([]string{"a", "b"}, nil, errors.New("network is unreachable"))
+	})
+	if strings.Contains(out, "not on the git server") {
+		t.Errorf("an unreachable server was reported as missing repositories: %q", out)
+	}
+	if !strings.Contains(out, "not reachable") {
+		t.Errorf("no hint that the server was unreachable: %q", out)
+	}
+}
+
+// TestReportInventorySplitsSides is the join that plain git cannot do.
+func TestReportInventorySplitsSides(t *testing.T) {
+	out := captureStdout(t, func() {
+		reportInventory([]string{"both", "onlyhere"}, []string{"both", "onlythere"}, nil)
+	})
+	if !strings.Contains(out, "not on the git server:") || !strings.Contains(out, "onlyhere") {
+		t.Errorf("local-only project not reported: %q", out)
+	}
+	if !strings.Contains(out, "not cloned here:") || !strings.Contains(out, "onlythere") {
+		t.Errorf("server-only project not reported: %q", out)
+	}
+	if strings.Contains(out, "both") {
+		t.Errorf("a project present on both sides should not be listed: %q", out)
+	}
+}
+
+func TestShortAge(t *testing.T) {
+	cases := []struct {
+		d    time.Duration
+		want string
+	}{
+		{30 * time.Second, "now"},
+		{90 * time.Second, "1m"},
+		{2 * time.Hour, "2h"},
+		{36 * time.Hour, "1d"},
+		{20 * 24 * time.Hour, "20d"},
+	}
+	for _, c := range cases {
+		if got := shortAge(c.d); got != c.want {
+			t.Errorf("shortAge(%v) = %q, want %q", c.d, got, c.want)
+		}
+	}
+}
+
+// captureStdout collects everything a function prints.
+func captureStdout(t *testing.T, fn func()) string {
+	t.Helper()
+	old := os.Stdout
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.Stdout = w
+	done := make(chan string)
+	go func() {
+		var b strings.Builder
+		io.Copy(&b, r)
+		done <- b.String()
+	}()
+	fn()
+	w.Close()
+	os.Stdout = old
+	return <-done
+}