feat(report): clean header + adaptive columns + geeky progress; refresh demo GIF

- Header: short banner (`kubetidy · <context>`) with the data source moved to an
  aligned hero "Source" line using a friendly tier name (e.g. "kubetidy operator
  (Tier 0, no Prometheus)") instead of the bare "0 (kubetidy operator)". Waste line
  now also carries the workload count.
- Adaptive columns: avg/p99 columns appear only when there's data, so an older
  operator (p95/peak only) renders a clean table, not a column of "—".
- Geeky progress: while the (now concurrent) scan runs, show a live bar + count +
  a phrase that advances with progress — "⟦▰▰▰▰▰▱▱▱▱▱⟧ 51/102 · pricing the waste…".
- Demo GIF re-recorded against the new card UX with real cpu+mem load generators.

Full gate + lint green.

Author: mayur-tolexo

docs/assets/demo.gif

@@ -3,6 +3,7 @@ package cli
 import (
 	"fmt"
 	"os"
+	"strings"
 	"sync"
 	"time"
 
@@ -71,6 +72,37 @@ func (s *spinner) update(status string) {
 	s.mu.Unlock()
 }
 
+// scanPhrases narrate the scan as it advances — a little personality for the wait. The phrase
+// is chosen by progress fraction, so it reads like a story from start to finish.
+var scanPhrases = []string{
+	"reading usage from the cluster…",
+	"crunching p50 / p95 / p99…",
+	"hunting over-provisioned pods…",
+	"pricing the waste in dollars…",
+	"checking memory for OOM traps…",
+	"scoring cluster efficiency…",
+	"tidying up…",
+}
+
+// scanProgress renders a catchy progress line: a mini bar, the count, and a phrase that advances
+// with the scan, e.g. "⟦▰▰▰▰▰▱▱▱▱▱⟧ 51/102 · pricing the waste in dollars…".
+func scanProgress(done, total int) string {
+	const w = 14
+	if total < 1 {
+		total = 1
+	}
+	if done > total {
+		done = total
+	}
+	filled := done * w / total
+	bar := strings.Repeat("▰", filled) + strings.Repeat("▱", w-filled)
+	idx := done * len(scanPhrases) / total
+	if idx >= len(scanPhrases) {
+		idx = len(scanPhrases) - 1
+	}
+	return fmt.Sprintf("⟦%s⟧ %d/%d · %s", bar, done, total, scanPhrases[idx])
+}
+
 // finish halts the animation and clears the spinner line so the report renders cleanly.
 func (s *spinner) finish() {
 	if !s.enabled {

internal/cli/progress.go

@@ -0,0 +1,20 @@
+package cli
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestScanProgress(t *testing.T) {
+	start := scanProgress(0, 102)
+	if !strings.Contains(start, "0/102") || !strings.Contains(start, scanPhrases[0]) {
+		t.Errorf("start = %q", start)
+	}
+	end := scanProgress(102, 102)
+	if !strings.Contains(end, "102/102") || !strings.Contains(end, scanPhrases[len(scanPhrases)-1]) {
+		t.Errorf("end = %q", end)
+	}
+	// Robust to edge inputs (no panic / out-of-range).
+	_ = scanProgress(0, 0)
+	_ = scanProgress(5, 1) // done > total clamps
+}

internal/cli/progress_test.go

@@ -114,7 +114,7 @@ func runEngineWithClients(ctx context.Context, f *scanFlags, clients *kube.Clien
 	}
 	if sp != nil {
 		engine.Progress = func(done, total int) {
-			sp.update(fmt.Sprintf("analyzing workloads… %d/%d", done, total))
+			sp.update(scanProgress(done, total))
 		}
 	}
 	result, err := engine.Run(ctx)

internal/cli/scan.go

@@ -98,31 +98,23 @@ func Table(w io.Writer, result model.ScanResult, opts Options) error {
 	return err
 }
 
-// writeBanner emits the top context line, e.g.
-// "kubetidy · prod-us-east  ·  data: 1 (Prometheus)".
+// writeBanner emits a short top line: "kubetidy · <context>". The data source and provenance
+// move to an aligned "Source" line in the hero, so this stays clean even with a long context.
 func writeBanner(b *strings.Builder, result model.ScanResult, opts Options) {
 	ctx := result.Context
 	if ctx == "" {
 		ctx = "(no context)"
 	}
-	banner := fmt.Sprintf("kubetidy · %s  ·  data: %s", ctx, result.Tier.String())
-	// Window + typical sample count are uniform across a scan, so state them ONCE here rather
-	// than repeating on every row. Exact per-workload samples live in --explain.
-	if w := observedWindow(result); w > 0 {
-		banner += fmt.Sprintf("  ·  %s history", formatWindow(w))
-		if s := typicalSamples(result); s > 0 {
-			banner += fmt.Sprintf(", ~%s samples/workload", formatCount(s))
-		}
-	}
+	banner := "kubetidy · " + ctx
 	if opts.Color {
 		fmt.Fprintf(b, "%s%s%s\n", ansiBold+ansiCyan, banner, ansiReset)
 	} else {
 		b.WriteString(banner + "\n")
 	}
 }
 
-// writeHero emits the hero summary: efficiency score (with a bar when colored), the dollar
-// waste, and a one-line takeaway counting the rightsizing opportunities.
+// writeHero emits the hero block: efficiency score (with a bar when colored), the dollar waste
+// + workload count, and an aligned Source line naming the data tier, window and sample count.
 func writeHero(b *strings.Builder, result model.ScanResult, opts Options) {
 	if opts.Color {
 		fmt.Fprintf(b, "  Efficiency  %d/100  %s\n", result.EfficiencyScore, scoreBar(result.EfficiencyScore))
@@ -132,24 +124,53 @@ func writeHero(b *strings.Builder, result model.ScanResult, opts Options) {
 
 	waste := formatDollars(result.TotalMonthlyWaste)
 	if opts.Color {
-		fmt.Fprintf(b, "  Waste       %s%s/mo%s  potential savings\n", ansiBold, waste, ansiReset)
+		fmt.Fprintf(b, "  Waste       %s%s/mo%s  potential savings · %s\n", ansiBold, waste, ansiReset, takeaway(result))
 	} else {
-		fmt.Fprintf(b, "  Waste       %s/mo  potential savings\n", waste)
+		fmt.Fprintf(b, "  Waste       %s/mo  potential savings · %s\n", waste, takeaway(result))
 	}
 
-	b.WriteString("  " + takeaway(result) + "\n")
+	fmt.Fprintf(b, "  Source      %s\n", sourceLine(result))
 }
 
-// takeaway is the one-line human summary under the hero numbers.
+// takeaway is the short workload-count phrase shown beside the waste figure.
 func takeaway(result model.ScanResult) string {
-	n := len(result.Recommendations)
-	switch n {
+	switch n := len(result.Recommendations); n {
 	case 0:
-		return "no workloads need rightsizing"
+		return "nothing to rightsize"
 	case 1:
-		return "1 workload can be rightsized"
+		return "1 workload to rightsize"
+	default:
+		return fmt.Sprintf("%d workloads to rightsize", n)
+	}
+}
+
+// sourceLine describes where the numbers came from: the data tier (friendly name), and — for
+// time-series tiers — the observation window and typical sample count.
+func sourceLine(result model.ScanResult) string {
+	s := tierSource(result.Tier)
+	if w := observedWindow(result); w > 0 {
+		s += fmt.Sprintf(" · %s history", formatWindow(w))
+		if n := typicalSamples(result); n > 0 {
+			s += fmt.Sprintf(", ~%s samples/workload", formatCount(n))
+		}
+	}
+	return s
+}
+
+// tierSource is the human-friendly data-source name for a tier (without the bare tier number
+// that EvidenceTier.String carries, which reads oddly in prose).
+func tierSource(t model.EvidenceTier) string {
+	switch t {
+	case model.TierOperator:
+		return "kubetidy operator (Tier 0, no Prometheus)"
+	case model.TierHistorical:
+		return "Prometheus (Tier 1)"
+	case model.TierAllocated:
+		return "OpenCost (Tier 2)"
+	case model.TierSnapshot:
+		return "metrics-server snapshot (limited — single reading)"
 	default:
-		return fmt.Sprintf("%d workloads can be rightsized", n)
+		return "spec only (no usage data)"
 	}
 }
 

internal/report/report.go

@@ -91,7 +91,7 @@ func TestTableBanner(t *testing.T) {
 	}
 	out := buf.String()
 
-	wantBanner := "kubetidy · prod-us-east  ·  data: 1 (Prometheus)"
+	wantBanner := "kubetidy · prod-us-east"
 	if !strings.Contains(out, wantBanner) {
 		t.Errorf("missing banner line %q\n--- got ---\n%s", wantBanner, out)
 	}
@@ -118,9 +118,13 @@ func TestTableHeroSummary(t *testing.T) {
 	if !strings.Contains(out, "Waste       $7,420/mo  potential savings") {
 		t.Errorf("missing hero waste line\n--- got ---\n%s", out)
 	}
-	if !strings.Contains(out, "2 workloads can be rightsized") {
+	if !strings.Contains(out, "2 workloads to rightsize") {
 		t.Errorf("missing one-line takeaway\n--- got ---\n%s", out)
 	}
+	// Source line names the tier in friendly prose (not the bare "1 (Prometheus)").
+	if !strings.Contains(out, "Source") || !strings.Contains(out, "Prometheus (Tier 1)") {
+		t.Errorf("missing/non-friendly Source line\n--- got ---\n%s", out)
+	}
 }
 
 func TestTakeawaySingular(t *testing.T) {
@@ -130,7 +134,7 @@ func TestTakeawaySingular(t *testing.T) {
 	if err := Table(&buf, r, Options{Color: false}); err != nil {
 		t.Fatalf("Table: %v", err)
 	}
-	if !strings.Contains(buf.String(), "1 workload can be rightsized") {
+	if !strings.Contains(buf.String(), "1 workload to rightsize") {
 		t.Errorf("singular takeaway wrong\n--- got ---\n%s", buf.String())
 	}
 }