refactor(repo): mirror get owner/repo renders a record, not a list

The owner/repo drill-down now reads as a detail view: bold repo name,
dim-labeled identity fields (private, access when known), then a
CLUSTER / CLONE URL / STATUS table — cluster cyan, clone URL the
default foreground (it is this view's payload), status by lifecycle.
Repeating the repo name on every row is gone.

Data source moves from a ListMirrors owner sweep to one exact-match
/repos?filter= lookup plus the cluster catalog. That also makes --json
emit the same repoDirRow shape as list --json (placements nested), and
readies a candidate rendering (access + availability, no table) for
when the control plane's filter starts matching onboardable repos —
today it matches onboarded only, so the not-found error points at
`mirror list --available`. Placements sort by cluster slug for a
deterministic table.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Entire-Checkpoint: 01KY78J19CM3TP2ZV976P6VXRP

Author: gtrrz-victor

cmd/entire/cli/repo_mirror.go

@@ -1017,8 +1017,9 @@ func newRepoMirrorGetCmd() *cobra.Command {
 		Use:   "get <mirror>",
 		Short: "Show a repo's mirrors by owner/repo, or one mirror by ULID or clone URL",
 		Long: "Show a mirror, or every mirror of a repo. <mirror> is one of:\n\n" +
-			"  - <owner>/<repo>, as shown in the `mirror list` NAME column — lists that\n" +
-			"    repo's mirror on every cluster, with per-cluster clone URL and status\n" +
+			"  - <owner>/<repo>, as shown in the `mirror list` NAME column — shows the\n" +
+			"    repo (visibility, access) and its mirror on every cluster, with\n" +
+			"    per-cluster clone URL and status\n" +
 			"  - a mirror ULID\n" +
 			"  - an entire:// clone URL (entire://<cluster>/gh/<owner>/<repo>) — the form\n" +
 			"    `git clone` accepts; a trailing .git, as pasted from `git remote -v`, is\n" +
@@ -1051,19 +1052,13 @@ func newRepoMirrorGetCmd() *cobra.Command {
 				return runCoreObject(cmd, columnHeaders(mirrorColumns), mirrorRow, show)
 			}
 			// The owner/repo form is the drill-down from the grouped `mirror
-			// list` NAME column: one row per cluster mirror of that repo, so
-			// the per-placement detail the list aggregates away (clone URL,
-			// per-cluster status) is one copy-paste away. Like a ULID it
-			// carries no cluster coordinate, so it resolves on the active
-			// context's core.
-			if owner, repo, ok := parseOwnerRepoRef(ref); ok {
-				// Not paged, so the writer runCoreList renders to is the
-				// final one — but cells are still pre-colored for consistency
-				// with the list view (same status palette, yellow headers).
-				st := newStatusStyles(cmd.OutOrStdout())
-				return runCoreList(cmd, "", styledHeaders(st, columnHeaders(mirrorGetColumns)), mirrorGetRowStyled(st), func(ctx context.Context, c *coreapi.Client) ([]coreapi.Mirror, error) {
-					return listRepoMirrors(ctx, c, owner, repo)
-				})
+			// list` NAME column: a record view of that repo — visibility,
+			// access, then its mirror on every cluster with the per-placement
+			// detail the list aggregates away (clone URL, per-cluster
+			// status). Like a ULID it carries no cluster coordinate, so it
+			// resolves on the active context's core.
+			if _, _, ok := parseOwnerRepoRef(ref); ok {
+				return runRepoMirrorGetByName(cmd, ref)
 			}
 			clusterHost, _, _, _, err := parseMirrorCloneURL(ref)
 			if err != nil {
@@ -1077,35 +1072,108 @@ func newRepoMirrorGetCmd() *cobra.Command {
 	return cmd
 }
 
-// mirrorGetColumns is the per-cluster view `get <owner/repo>` renders: one row
-// per mirror of the repo, the clone URL you'd copy, and each mirror's clone
-// lifecycle status — exactly the placement detail the grouped `mirror list`
-// row aggregates away.
-var mirrorGetColumns = []column{colName, colCloneURL, colPrivate, colStatus}
+// runRepoMirrorGetByName renders the record view behind `get <owner/repo>`:
+// the repo's identity fields (visibility, access), then its mirror placements
+// as a cluster/clone-URL/status table. One exact-match /repos?filter= lookup
+// (the endpoint returns that repo's zero-or-one entries; no directory walk)
+// plus the cluster catalog for clone-URL synthesis. A candidate entry renders
+// its access and availability instead of a placements table — though today's
+// control plane only matches onboarded repos in the filter, so that path
+// waits on the server (the not-found error points at `list --available`).
+// --json emits the same repoDirRow shape `list --json` uses, placements
+// nested.
+func runRepoMirrorGetByName(cmd *cobra.Command, ref string) error {
+	return runCore(cmd, func(ctx context.Context, c *coreapi.Client) error {
+		out, err := c.ListRepos(ctx, coreapi.ListReposParams{Filter: coreapi.NewOptString(ref)})
+		if err != nil {
+			return err
+		}
+		if len(out.Repos) == 0 {
+			// The filter only matches onboarded repos on today's control
+			// plane, so a not-yet-mirrored GitHub repo lands here too —
+			// point at the list mode that shows those.
+			return fmt.Errorf("no repo matching %q visible from your login (GitHub repos you could onboard: `entire repo mirror list --available`)", ref)
+		}
+		clusters, err := c.ListClusters(ctx)
+		if err != nil {
+			return err
+		}
+		row := mirrorRepoDetailRow(out.Repos[0], clusterHostBySlug(clusters.Clusters))
+		if jsonRequested(cmd) {
+			return printJSON(cmd.OutOrStdout(), row)
+		}
+		renderRepoDetail(cmd.OutOrStdout(), row)
+		return nil
+	})
+}
 
-func mirrorGetRow(m coreapi.Mirror) []string {
-	return append(mirrorRow(m), orDash(string(m.Status.Or(""))))
+// mirrorRepoDetailRow shapes one directory entry for the record view, reusing the
+// list's row builder so both views agree on placement/candidate semantics.
+// buildRepoDir drops a repo with no GitHub-mirror placements (a native
+// `entire repo create` repo); the detail view was asked about that repo by
+// name, so it falls back to a bare identity row instead of vanishing.
+// Placements are ordered by cluster slug for a deterministic table.
+func mirrorRepoDetailRow(e coreapi.RepoIndexEntry, hostBySlug map[string]string) repoDirRow {
+	rows := buildRepoDir([]coreapi.RepoIndexEntry{e}, hostBySlug)
+	if len(rows) == 0 {
+		name := e.FullName
+		if name == "" {
+			name = e.Name
+		}
+		return repoDirRow{Repo: name, Private: strings.EqualFold(e.Visibility, "private")}
+	}
+	row := rows[0]
+	slices.SortFunc(row.Placements, func(a, b repoDirPlacement) int {
+		return cmp.Compare(a.Cluster, b.Cluster)
+	})
+	return row
 }
 
-// mirrorGetRowStyled colors the per-cluster rows the way the list view does:
-// private gray, status by lifecycle, and the CLONE URL cyan — it is the
-// payload of this view (the one thing `get` shows that the grouped list
-// doesn't), and a cell left unstyled here would instead pick up printTable's
-// muted secondary-column gray, reading as de-emphasized. Cyan also matches
-// the list's cluster accent, and the URL is the cluster-bearing value.
-func mirrorGetRowStyled(st statusStyles) func(coreapi.Mirror) []string {
-	return func(m coreapi.Mirror) []string {
-		cells := mirrorGetRow(m)
-		if !st.colorEnabled {
-			return cells
+// renderRepoDetail prints the `get <owner/repo>` record: bold repo name,
+// dim-labeled identity fields, then the placements table — cluster cyan,
+// clone URL the default foreground (it is the payload of this view), status
+// by lifecycle. A candidate (no placements, availability in Status) states
+// its availability instead of an empty table; a native-only repo states it
+// has no GitHub mirrors.
+func renderRepoDetail(w io.Writer, row repoDirRow) {
+	st := newStatusStyles(w)
+	fmt.Fprintln(w, st.render(st.bold, row.Repo))
+	fields := []explainRow{{Label: "private", Value: yesNo(row.Private)}}
+	if row.Access != "" {
+		fields = append(fields, explainRow{Label: "access", Value: row.Access})
+	}
+	fmt.Fprint(w, st.metadataRows(fields))
+	fmt.Fprintln(w)
+
+	if len(row.Placements) == 0 {
+		if row.Status != "" {
+			fmt.Fprintf(w, "Not mirrored on any cluster (%s).\n", row.Status)
+			return
 		}
-		cells[1] = st.render(st.cyan, cells[1])
-		cells[2] = st.render(st.gray, cells[2])
-		if style, ok := repoStatusColor(st, cells[3]); ok {
-			cells[3] = st.render(style, cells[3])
+		fmt.Fprintln(w, "No GitHub mirror placements.")
+		return
+	}
+
+	headers := styledHeaders(st, []string{"CLUSTER", "CLONE URL", "STATUS"})
+	rows := make([][]string, len(row.Placements))
+	for i, p := range row.Placements {
+		cluster, status := p.Cluster, p.Status
+		if st.colorEnabled {
+			cluster = st.render(st.cyan, cluster)
+			if style, ok := repoStatusColor(st, status); ok {
+				status = st.render(style, status)
+			}
 		}
-		return cells
+		rows[i] = []string{cluster, orDash(p.CloneURL), status}
+	}
+	widths := columnWidths(headers, rows)
+	var b strings.Builder
+	plain := func(int) lipgloss.Style { return lipgloss.Style{} }
+	writeTableRow(&b, headers, widths, plain, tableStyles{})
+	for _, r := range rows {
+		writeTableRow(&b, r, widths, plain, tableStyles{})
 	}
+	fmt.Fprint(w, b.String())
 }
 
 // parseOwnerRepoRef reads a bare <owner>/<repo> mirror reference — the NAME
@@ -1123,43 +1191,6 @@ func parseOwnerRepoRef(ref string) (owner, repo string, ok bool) {
 	return owner, repo, true
 }
 
-// listRepoMirrors fetches every caller-visible mirror of owner/repo on the
-// active context's core, ordered by cluster host for a deterministic table.
-// No mirrors is an error, not an empty table: `get` names one repo, so
-// nothing-found means the reference didn't resolve.
-func listRepoMirrors(ctx context.Context, c *coreapi.Client, owner, repo string) ([]coreapi.Mirror, error) {
-	mirrors, err := fetchAllPages(ctx, func(ctx context.Context, cursor string) ([]coreapi.Mirror, string, error) {
-		params := coreapi.ListMirrorsParams{
-			Provider: coreapi.NewOptString("github"),
-			Owner:    coreapi.NewOptString(owner),
-		}
-		if cursor != "" {
-			params.PageToken = coreapi.NewOptString(cursor)
-		}
-		out, lerr := c.ListMirrors(ctx, params)
-		if lerr != nil {
-			return nil, "", lerr
-		}
-		return out.Mirrors, out.NextPageToken.Or(""), nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	// ListMirrors has no repo filter, so the owner-scoped result is matched
-	// on repo client-side; owner/repo are stored lowercase, EqualFold guards
-	// a differently-cased argument.
-	mirrors = slices.DeleteFunc(mirrors, func(m coreapi.Mirror) bool {
-		return !strings.EqualFold(m.Repo, repo)
-	})
-	if len(mirrors) == 0 {
-		return nil, noMirrorErr(owner + "/" + repo)
-	}
-	slices.SortFunc(mirrors, func(a, b coreapi.Mirror) int {
-		return cmp.Compare(a.ClusterHost, b.ClusterHost)
-	})
-	return mirrors, nil
-}
-
 // resolveMirrorRef turns a mirror reference into its ULID. A ULID passes
 // through unchanged. Otherwise the ref is parsed as an entire:// clone URL and
 // resolved by listing the caller-visible mirrors for that (cluster, provider,

cmd/entire/cli/repo_mirror_test.go

@@ -1311,13 +1311,13 @@ func TestRepoMirrorGet_Routing(t *testing.T) {
 		clusterCoreClient = fn
 		t.Cleanup(func() { clusterCoreClient = prev })
 	}
-	runGet := func(t *testing.T, ref string) (string, error) {
+	runGet := func(t *testing.T, args ...string) (string, error) {
 		t.Helper()
 		cmd := newRepoCmd()
 		var out, errW bytes.Buffer
 		cmd.SetOut(&out)
 		cmd.SetErr(&errW)
-		cmd.SetArgs([]string{"mirror", "get", ref})
+		cmd.SetArgs(append([]string{"mirror", "get"}, args...))
 		err := cmd.ExecuteContext(t.Context())
 		return out.String(), err
 	}
@@ -1368,24 +1368,23 @@ func TestRepoMirrorGet_Routing(t *testing.T) {
 		require.ErrorContains(t, err, "pass a mirror ULID or a clone URL")
 	})
 
-	t.Run("owner/repo lists every cluster mirror with clone URL and status", func(t *testing.T) {
-		// The drill-down from the grouped `mirror list` NAME cell: one row per
-		// cluster mirror, per-cluster clone URL + status, deterministic
-		// (cluster-host) order. The owner narrowing is server-side; the repo
-		// match is client-side (ListMirrors has no repo filter), so the
-		// sibling repo must not leak in.
-		var gotOwner, gotProvider string
+	// serveRepoDetail answers the two endpoints the owner/repo form uses: the
+	// exact-match /repos?filter= lookup and the cluster catalog.
+	serveRepoDetail := func(t *testing.T, repos []coreapi.RepoIndexEntry, clusters []coreapi.Cluster) *string {
+		t.Helper()
+		var gotFilter string
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			w.Header().Set("Content-Type", "application/json")
-			assert.Equal(t, mirrorsAPIPath, r.URL.Path)
-			gotOwner, gotProvider = r.URL.Query().Get("owner"), r.URL.Query().Get("provider")
-			assert.NoError(t, printJSON(w, &coreapi.ListMirrorsOutputBody{Mirrors: []coreapi.Mirror{
-				{MirrorId: "M2", Owner: "entirehq", Repo: "entiredb", ClusterHost: "eu-west-1.entire.io",
-					IsPrivate: coreapi.NewOptBool(true), Status: coreapi.NewOptMirrorStatus(coreapi.MirrorStatusFailed)},
-				{MirrorId: "M3", Owner: "entirehq", Repo: "other", ClusterHost: "aws-us-east-2.entire.io"},
-				{MirrorId: "M1", Owner: "entirehq", Repo: "entiredb", ClusterHost: "aws-us-east-2.entire.io",
-					IsPrivate: coreapi.NewOptBool(true), Status: coreapi.NewOptMirrorStatus(coreapi.MirrorStatusReady)},
-			}}))
+			switch r.URL.Path {
+			case testClustersPath:
+				assert.NoError(t, printJSON(w, &coreapi.ListClustersOutputBody{Clusters: clusters}))
+			case testReposPath:
+				gotFilter = r.URL.Query().Get("filter")
+				assert.NoError(t, printJSON(w, &coreapi.ListReposOutputBody{Repos: repos}))
+			default:
+				t.Errorf("unexpected path %q", r.URL.Path)
+				w.WriteHeader(http.StatusNotFound)
+			}
 		}))
 		t.Cleanup(srv.Close)
 		seamActive(t, func(context.Context) (*coreapi.Client, error) {
@@ -1395,30 +1394,68 @@ func TestRepoMirrorGet_Routing(t *testing.T) {
 			t.Errorf("owner/repo get dialed cluster core %q; it has no cluster coordinate", host)
 			return nil, errors.New("wrong core")
 		})
+		return &gotFilter
+	}
+	detailClusters := []coreapi.Cluster{
+		{Slug: "us", PublicUrl: "https://aws-us-east-2.entire.io"},
+		{Slug: "eu", PublicUrl: "https://eu-west-1.entire.io"},
+	}
+
+	t.Run("owner/repo renders the record view with a per-cluster table", func(t *testing.T) {
+		// The drill-down from the grouped `mirror list` NAME cell: identity
+		// fields, then one row per cluster mirror with clone URL + status,
+		// deterministic (cluster-slug) order — the entry delivers eu-first.
+		gotFilter := serveRepoDetail(t, []coreapi.RepoIndexEntry{
+			{FullName: "entirehq/entiredb", Visibility: "private", Placements: []coreapi.RepoPlacement{
+				{ClusterSlug: "eu", Status: coreapi.RepoPlacementStatusFailed, Mirror: true},
+				{ClusterSlug: "us", Status: coreapi.RepoPlacementStatusReady, Mirror: true},
+			}},
+		}, detailClusters)
 
 		out, err := runGet(t, "entirehq/entiredb")
 		require.NoError(t, err)
-		require.Equal(t, "entirehq", gotOwner, "owner narrowing must be server-side")
-		require.Equal(t, "github", gotProvider)
+		require.Equal(t, "entirehq/entiredb", *gotFilter, "the lookup must be the server-side exact-match filter")
 		requireOrder(t, out,
-			"entire://aws-us-east-2.entire.io/gh/entirehq/entiredb", "ready",
-			"entire://eu-west-1.entire.io/gh/entirehq/entiredb", "failed",
+			"entirehq/entiredb",
+			"private", "yes",
+			"CLUSTER", "CLONE URL", "STATUS",
+			"eu", "entire://eu-west-1.entire.io/gh/entirehq/entiredb", "failed",
+			"us", "entire://aws-us-east-2.entire.io/gh/entirehq/entiredb", "ready",
 		)
-		require.NotContains(t, out, "entirehq/other", "the sibling repo must not leak into the match")
 	})
 
-	t.Run("owner/repo with no mirrors is a friendly error", func(t *testing.T) {
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			assert.NoError(t, printJSON(w, &coreapi.ListMirrorsOutputBody{}))
-		}))
-		t.Cleanup(srv.Close)
-		seamActive(t, func(context.Context) (*coreapi.Client, error) {
-			return coreapi.NewWithBearer(srv.URL, "tok")
-		})
+	t.Run("owner/repo on a candidate shows access and availability, no table", func(t *testing.T) {
+		serveRepoDetail(t, []coreapi.RepoIndexEntry{
+			candidateEntry("entirehq/notyet", "private", coreapi.RepoCandidateAccessWrite, true),
+		}, detailClusters)
+
+		out, err := runGet(t, "entirehq/notyet")
+		require.NoError(t, err)
+		requireOrder(t, out, "entirehq/notyet", "private", "yes", "access", "write", "Not mirrored on any cluster (available).")
+		require.NotContains(t, out, "CLONE URL", "a candidate has no placements table")
+	})
+
+	t.Run("owner/repo --json emits the list's row shape, placements nested", func(t *testing.T) {
+		serveRepoDetail(t, []coreapi.RepoIndexEntry{
+			{FullName: "entirehq/entiredb", Visibility: "private", Placements: []coreapi.RepoPlacement{
+				{ClusterSlug: "us", Status: coreapi.RepoPlacementStatusReady, Mirror: true},
+			}},
+		}, detailClusters)
+
+		out, err := runGet(t, "entirehq/entiredb", "--json")
+		require.NoError(t, err)
+		var row repoDirRow
+		require.NoError(t, json.Unmarshal([]byte(out), &row))
+		require.Equal(t, repoDirRow{Repo: "entirehq/entiredb", Private: true, Status: "ready", Placements: []repoDirPlacement{
+			{Cluster: "us", Status: "ready", CloneURL: "entire://aws-us-east-2.entire.io/gh/entirehq/entiredb"},
+		}}, row)
+	})
+
+	t.Run("owner/repo with no matching repo is a friendly error", func(t *testing.T) {
+		serveRepoDetail(t, nil, detailClusters)
 		_, err := runGet(t, "entirehq/ghost")
 		require.Error(t, err)
-		require.ErrorContains(t, err, "no mirror matching")
+		require.ErrorContains(t, err, "no repo matching")
 	})
 }
 
@@ -1551,9 +1588,6 @@ func TestStyledCellsDisabledGate(t *testing.T) {
 
 	headers := columnHeaders(repoDirColumns)
 	require.Equal(t, headers, styledHeaders(st, headers))
-
-	m := coreapi.Mirror{Owner: "acme", Repo: "web", ClusterHost: "h", Status: coreapi.NewOptMirrorStatus(coreapi.MirrorStatusReady)}
-	require.Equal(t, mirrorGetRow(m), mirrorGetRowStyled(st)(m))
 }
 
 func TestClusterHostBySlug(t *testing.T) {