fix: Stats TUI (#14)

* fix: Stats TUI

* fix: TUI wrapping bug

* fix: stats TUI header

* fix: Code review fixes

Author: abhisek

cli/stats.go

@@ -12,6 +12,7 @@ import (
 
 type statsParams struct {
 	since string
+	until string
 	agent string
 }
 
@@ -27,6 +28,7 @@ Displays overview metrics, activity breakdown, agent stats, timeline,
 code changes, command results, error rates, and session info.`,
 		Example: `  gryph stats
   gryph stats --since 7d
+  gryph stats --since 2w --until 1w
   gryph stats --since 30d --agent claude-code`,
 		RunE: func(cmd *cobra.Command, args []string) error {
 			ctx := context.Background()
@@ -68,6 +70,14 @@ code changes, command results, error rates, and session info.`,
 				opts.Since = &t
 			}
 
+			if p.until != "" {
+				t, err := parseDuration(p.until)
+				if err != nil {
+					return fmt.Errorf("invalid --until value %q: %w", p.until, err)
+				}
+				opts.Until = &t
+			}
+
 			prog := tea.NewProgram(stats.New(opts), tea.WithAltScreen())
 			_, err = prog.Run()
 
@@ -76,6 +86,7 @@ code changes, command results, error rates, and session info.`,
 	}
 
 	cmd.Flags().StringVar(&p.since, "since", "today", "time range: today, 7d, 30d, all, or duration (30m, 1h, 2w)")
+	cmd.Flags().StringVar(&p.until, "until", "", "end of time window (same syntax as --since)")
 	cmd.Flags().StringVar(&p.agent, "agent", "", "filter by agent name")
 
 	return cmd

core/session/session.go

@@ -111,6 +111,12 @@ func (f *SessionFilter) WithSince(t time.Time) *SessionFilter {
 	return f
 }
 
+// WithUntil sets the Until filter.
+func (f *SessionFilter) WithUntil(t time.Time) *SessionFilter {
+	f.Until = &t
+	return f
+}
+
 // WithLimit sets the Limit.
 func (f *SessionFilter) WithLimit(limit int) *SessionFilter {
 	f.Limit = limit

tui/component/stats/agents.go

@@ -14,11 +14,13 @@ func renderAgents(data *StatsData, width, height int) string {
 	}
 
 	var b strings.Builder
-	b.WriteString(fmt.Sprintf("  %s %s %s %s\n",
-		labelStyle.Width(14).Render("Agent"),
-		labelStyle.Width(6).Align(lipgloss.Right).Render("Sess"),
-		labelStyle.Width(8).Align(lipgloss.Right).Render("Events"),
-		labelStyle.Width(6).Align(lipgloss.Right).Render("Errs"),
+	b.WriteString(fmt.Sprintf("  %s %s %s %s %s %s\n",
+		labelStyle.Width(12).Render("Agent"),
+		labelStyle.Width(5).Align(lipgloss.Right).Render("Sess"),
+		labelStyle.Width(6).Align(lipgloss.Right).Render("Evts"),
+		labelStyle.Width(5).Align(lipgloss.Right).Render("Wrts"),
+		labelStyle.Width(5).Align(lipgloss.Right).Render("Cmds"),
+		labelStyle.Width(5).Align(lipgloss.Right).Render("Errs"),
 	))
 
 	maxAgents := height - 3
@@ -31,13 +33,15 @@ func renderAgents(data *StatsData, width, height int) string {
 
 	for _, a := range data.Agents[:maxAgents] {
 		name := lipgloss.NewStyle().Foreground(agentColor(a.Name)).Render(
-			tui.TruncateString(a.Name, 14),
+			tui.TruncateString(a.Name, 12),
 		)
-		b.WriteString(fmt.Sprintf("  %s %s %s %s\n",
-			tui.PadRightVisible(name, 14),
-			valueStyle.Width(6).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.Sessions)),
-			valueStyle.Width(8).Align(lipgloss.Right).Render(tui.FormatNumber(a.Events)),
-			redValueStyle.Width(6).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.Errors)),
+		b.WriteString(fmt.Sprintf("  %s %s %s %s %s %s\n",
+			tui.PadRightVisible(name, 12),
+			valueStyle.Width(5).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.Sessions)),
+			valueStyle.Width(6).Align(lipgloss.Right).Render(tui.FormatNumber(a.Events)),
+			valueStyle.Width(5).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.FilesWritten)),
+			valueStyle.Width(5).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.Commands)),
+			redValueStyle.Width(5).Align(lipgloss.Right).Render(fmt.Sprintf("%d", a.Errors)),
 		))
 	}
 

tui/component/stats/data.go

@@ -2,6 +2,7 @@ package stats
 
 import (
 	"context"
+	"fmt"
 	"sort"
 	"time"
 
@@ -33,6 +34,11 @@ type CommandStat struct {
 	FailCount int
 }
 
+type TimelineBucket struct {
+	Label string
+	Count int
+}
+
 type StatsData struct {
 	TotalEvents    int
 	TotalSessions  int
@@ -48,7 +54,7 @@ type StatsData struct {
 
 	Agents []AgentStat
 
-	HourlyBuckets [24]int
+	TimelineBuckets []TimelineBucket
 
 	LinesAdded        int
 	LinesRemoved      int
@@ -69,18 +75,22 @@ type StatsData struct {
 	AvgActionsPerSess float64
 	LongestSession    time.Duration
 	ShortestSession   time.Duration
+	PeakConcurrent    int
 
 	TimeSpanStart time.Time
 	TimeSpanEnd   time.Time
 }
 
-func computeStats(ctx context.Context, store storage.Store, since *time.Time, agentFilter string) (*StatsData, error) {
+func computeStats(ctx context.Context, store storage.Store, since, until *time.Time, agentFilter string) (*StatsData, error) {
 	data := &StatsData{}
 
 	sessionFilter := session.NewSessionFilter().WithLimit(10000)
 	if since != nil {
 		sessionFilter = sessionFilter.WithSince(*since)
 	}
+	if until != nil {
+		sessionFilter = sessionFilter.WithUntil(*until)
+	}
 	if agentFilter != "" {
 		sessionFilter = sessionFilter.WithAgent(agentFilter)
 	}
@@ -135,6 +145,8 @@ func computeStats(ctx context.Context, store storage.Store, since *time.Time, ag
 		data.AvgDuration = totalDuration / time.Duration(sessionCount)
 	}
 
+	data.PeakConcurrent = computePeakConcurrent(sessions)
+
 	data.UniqueAgents = len(agentMap)
 	for _, as := range agentMap {
 		data.Agents = append(data.Agents, *as)
@@ -147,6 +159,9 @@ func computeStats(ctx context.Context, store storage.Store, since *time.Time, ag
 	if since != nil {
 		eventFilter = eventFilter.WithSince(*since)
 	}
+	if until != nil {
+		eventFilter = eventFilter.WithUntil(*until)
+	}
 	if agentFilter != "" {
 		eventFilter = eventFilter.WithAgents(agentFilter)
 	}
@@ -177,9 +192,6 @@ func computeStats(ctx context.Context, store storage.Store, since *time.Time, ag
 			data.TimeSpanEnd = e.Timestamp
 		}
 
-		hour := e.Timestamp.Local().Hour()
-		data.HourlyBuckets[hour]++
-
 		switch e.ResultStatus {
 		case events.ResultError:
 			data.TotalErrors++
@@ -269,5 +281,113 @@ func computeStats(ctx context.Context, store storage.Store, since *time.Time, ag
 		data.TopCommands = data.TopCommands[:10]
 	}
 
+	data.TimelineBuckets = computeTimelineBuckets(evts, since, until)
+
 	return data, nil
 }
+
+func computeTimelineBuckets(evts []*events.Event, since, until *time.Time) []TimelineBucket {
+	now := time.Now()
+	effectiveSince := now.Add(-24 * time.Hour)
+	effectiveUntil := now
+	if since != nil {
+		effectiveSince = *since
+	}
+	if until != nil {
+		effectiveUntil = *until
+	}
+
+	span := effectiveUntil.Sub(effectiveSince)
+
+	if span <= 24*time.Hour {
+		return computeHourlyBuckets(evts)
+	}
+	return computeDailyBuckets(evts, effectiveSince, effectiveUntil)
+}
+
+func computeHourlyBuckets(evts []*events.Event) []TimelineBucket {
+	counts := [24]int{}
+	for _, e := range evts {
+		h := e.Timestamp.Local().Hour()
+		counts[h]++
+	}
+	buckets := make([]TimelineBucket, 24)
+	for h := 0; h < 24; h++ {
+		buckets[h] = TimelineBucket{
+			Label: fmt.Sprintf("%02d", h),
+			Count: counts[h],
+		}
+	}
+	return buckets
+}
+
+func computeDailyBuckets(evts []*events.Event, since, until time.Time) []TimelineBucket {
+	sinceLocal := since.Local()
+	untilLocal := until.Local()
+	startDay := time.Date(sinceLocal.Year(), sinceLocal.Month(), sinceLocal.Day(), 0, 0, 0, 0, sinceLocal.Location())
+	endDay := time.Date(untilLocal.Year(), untilLocal.Month(), untilLocal.Day(), 0, 0, 0, 0, untilLocal.Location())
+
+	days := int(endDay.Sub(startDay).Hours()/24) + 1
+	if days < 1 {
+		days = 1
+	}
+
+	buckets := make([]TimelineBucket, days)
+	for i := 0; i < days; i++ {
+		day := startDay.AddDate(0, 0, i)
+		if days <= 14 {
+			buckets[i].Label = day.Format("Mon")
+		} else {
+			buckets[i].Label = day.Format("Jan 2")
+		}
+	}
+
+	for _, e := range evts {
+		local := e.Timestamp.Local()
+		idx := int(time.Date(local.Year(), local.Month(), local.Day(), 0, 0, 0, 0, local.Location()).Sub(startDay).Hours() / 24)
+		if idx >= 0 && idx < days {
+			buckets[idx].Count++
+		}
+	}
+
+	return buckets
+}
+
+func computePeakConcurrent(sessions []*session.Session) int {
+	if len(sessions) == 0 {
+		return 0
+	}
+
+	type endpoint struct {
+		t     time.Time
+		delta int
+	}
+
+	var points []endpoint
+	for _, s := range sessions {
+		if s.EndedAt.IsZero() {
+			continue
+		}
+		points = append(points,
+			endpoint{t: s.StartedAt, delta: 1},
+			endpoint{t: s.EndedAt, delta: -1},
+		)
+	}
+
+	sort.Slice(points, func(i, j int) bool {
+		if points[i].t.Equal(points[j].t) {
+			return points[i].delta > points[j].delta
+		}
+		return points[i].t.Before(points[j].t)
+	})
+
+	peak := 0
+	current := 0
+	for _, p := range points {
+		current += p.delta
+		if current > peak {
+			peak = current
+		}
+	}
+	return peak
+}

tui/component/stats/header.go

@@ -10,21 +10,29 @@ type headerModel struct {
 	agentFilter string
 	lastRefresh time.Time
 	customSince *time.Time
+	customUntil *time.Time
 }
 
-func newHeaderModel(timeRange TimeRange, agentFilter string, customSince *time.Time) headerModel {
+func newHeaderModel(timeRange TimeRange, agentFilter string, customSince, customUntil *time.Time) headerModel {
 	return headerModel{
 		timeRange:   timeRange,
 		agentFilter: agentFilter,
 		customSince: customSince,
+		customUntil: customUntil,
 	}
 }
 
 func (h headerModel) view(width int) string {
 	title := "gryph stats"
 	var rangeTxt string
-	if h.customSince != nil {
+	if h.customSince != nil && h.customUntil != nil {
+		rangeTxt = fmt.Sprintf("%s – %s",
+			h.customSince.Local().Format("Jan 2 15:04"),
+			h.customUntil.Local().Format("Jan 2 15:04"))
+	} else if h.customSince != nil {
 		rangeTxt = fmt.Sprintf("Since %s", h.customSince.Local().Format("2006-01-02 15:04"))
+	} else if h.customUntil != nil {
+		rangeTxt = fmt.Sprintf("%s until %s", h.timeRange.String(), h.customUntil.Local().Format("Jan 2 15:04"))
 	} else {
 		rangeTxt = h.timeRange.String()
 	}

tui/component/stats/help.go

@@ -28,6 +28,8 @@ var helpBindings = []struct {
 	{"w", "Time range: 7 days"},
 	{"m", "Time range: 30 days"},
 	{"a", "Time range: All"},
+	{"[", "Shift window back"},
+	{"]", "Shift window forward"},
 	{"r", "Force refresh"},
 }