feat(tui): add timer system for presentations

- Add `Timer` struct with start, stop, pause, resume functionality
- Add `TimerDisplay` component with toggle visibility and overlay rendering
- Integrate per-slide timers and global presentation timer
- Add timer update handling in slide and main model updates
- Add 't' key binding to toggle timer display
- Add timer navigation helpers to pause/resume on slide transitions

Author: tharropoulos

internal/tui/slide.go

@@ -18,6 +18,7 @@ type Slide struct {
 	ActiveTransition transitions.Transition
 	Properties       config.Properties
 	Title            string
+	Timer            Timer
 
 	preRenderedFrame string
 }
@@ -33,7 +34,12 @@ func (s *Slide) Update() (*Slide, tea.Cmd) {
 	if cmd == nil {
 		s.preRenderedFrame = ""
 	}
-	return s, cmd
+
+	// Update timer
+	var timerCmd tea.Cmd
+	s.Timer, timerCmd = s.Timer.Update(TimerTickMsg{})
+
+	return s, tea.Batch(cmd, timerCmd)
 }
 
 func (s Slide) View() string {

internal/tui/timer.go

@@ -0,0 +1,140 @@
+package tui
+
+import (
+	"fmt"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
+)
+
+type TimerTickMsg struct{}
+
+type Timer struct {
+	startTime time.Time
+	duration  time.Duration
+	running   bool
+}
+
+func NewTimer() Timer {
+	return Timer{
+		startTime: time.Now(),
+		duration:  0,
+		running:   false,
+	}
+}
+
+func (t Timer) Start() Timer {
+	if !t.running {
+		t.startTime = time.Now()
+		t.duration = 0
+		t.running = true
+	}
+	return t
+}
+
+
+func (t Timer) Reset() Timer {
+	t.startTime = time.Now()
+	t.duration = 0
+	return t
+}
+
+func (t Timer) Pause() Timer {
+	if t.running {
+		t.duration = time.Since(t.startTime)
+		t.running = false
+	}
+	return t
+}
+
+func (t Timer) Resume() Timer {
+	if !t.running {
+		t.startTime = time.Now().Add(-t.duration)
+		t.running = true
+	}
+	return t
+}
+
+func (t Timer) Update(msg tea.Msg) (Timer, tea.Cmd) {
+	switch msg.(type) {
+	case TimerTickMsg:
+		if t.running {
+			t.duration = time.Since(t.startTime)
+		}
+		return t, tea.Tick(time.Second, func(time.Time) tea.Msg {
+			return TimerTickMsg{}
+		})
+	}
+	return t, nil
+}
+
+func (t Timer) Duration() time.Duration {
+	if t.running {
+		return time.Since(t.startTime)
+	}
+	return t.duration
+}
+
+func (t Timer) FormatDuration() string {
+	d := t.Duration()
+	totalSeconds := int(d.Seconds())
+	minutes := totalSeconds / 60
+	seconds := totalSeconds % 60
+	return fmt.Sprintf("%02d:%02d", minutes, seconds)
+}
+
+func (t Timer) IsRunning() bool {
+	return t.running
+}
+
+type TimerDisplay struct {
+	visible bool
+}
+
+func NewTimerDisplay() TimerDisplay {
+	return TimerDisplay{
+		visible: false,
+	}
+}
+
+func (td TimerDisplay) Update(msg tea.Msg) (TimerDisplay, tea.Cmd) {
+	// TimerDisplay doesn't need to update timers, just handle display state
+	return td, nil
+}
+
+func (td TimerDisplay) Show(slideView string, width, height int, globalTimer Timer, slideTimer Timer) string {
+	if !td.visible {
+		return slideView
+	}
+
+	globalTimeStr := globalTimer.FormatDuration()
+	slideTimeStr := slideTimer.FormatDuration()
+
+	timerContent := lipgloss.NewStyle().
+		Background(lipgloss.Color("#2A2A2A")).
+		Foreground(lipgloss.Color("#DDDDDD")).
+		Padding(0, 1).
+		Render(fmt.Sprintf("Total:  %s\nSlide:  %s", globalTimeStr, slideTimeStr))
+
+	// Position in top left
+	timerX := 3
+	timerY := 1
+
+	return placeOverlay(timerX, timerY, timerContent, slideView)
+}
+
+func (td TimerDisplay) IsVisible() bool {
+	return td.visible
+}
+
+func (td TimerDisplay) ToggleVisible() TimerDisplay {
+	td.visible = !td.visible
+	return td
+}
+
+func EnsureTimerInitialized(slide *Slide) {
+	if slide != nil && slide.Timer.startTime.IsZero() && slide.Timer.duration == 0 && !slide.Timer.running {
+		slide.Timer = NewTimer()
+	}
+}

internal/tui/tui.go

@@ -6,6 +6,8 @@ import (
 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
 
+	"time"
+
 	"github.com/museslabs/kyma/internal/config"
 	"github.com/museslabs/kyma/internal/tui/transitions"
 )
@@ -19,6 +21,7 @@ type keyMap struct {
 	Command key.Binding
 	GoTo    key.Binding
 	Jump    key.Binding
+	Timer   key.Binding
 }
 
 func (k keyMap) ShortHelp() []key.Binding {
@@ -62,36 +65,66 @@ var keys = keyMap{
 		key.WithKeys("1", "2", "3", "4", "5", "6", "7", "8", "9"),
 		key.WithHelp("1-9", "jump slides"),
 	),
+	Timer: key.NewBinding(
+		key.WithKeys("t"),
+		key.WithHelp("t", "toggle timer"),
+	),
 }
 
 func style(width, height int, styleConfig config.StyleConfig) config.SlideStyle {
 	return styleConfig.Apply(width, height)
 }
 
+// navigateToSlide handles the common pattern of pausing current timer, switching slides, and resuming
+func (m *model) navigateToSlide(newSlide *Slide) {
+	if m.slide != nil {
+		m.slide.Timer = m.slide.Timer.Pause()
+	}
+	m.slide = newSlide
+	EnsureTimerInitialized(m.slide)
+	if m.slide != nil {
+		m.slide.Timer = m.slide.Timer.Resume()
+	}
+}
+
 type model struct {
 	width  int
 	height int
 
-	slide     *Slide
-	keys      keyMap
-	help      help.Model
-	command   *Command
-	goTo      *GoTo
-	jump      *Jump
-	rootSlide *Slide
+	slide        *Slide
+	keys         keyMap
+	help         help.Model
+	command      *Command
+	goTo         *GoTo
+	jump         *Jump
+	rootSlide    *Slide
+	globalTimer  Timer
+	timerDisplay TimerDisplay
 }
 
 func New(rootSlide *Slide) model {
+	// Initialize timer only for the first slide
+	if rootSlide != nil {
+		rootSlide.Timer = NewTimer().Start()
+	}
+
 	return model{
-		slide:     rootSlide,
-		keys:      keys,
-		help:      help.New(),
-		rootSlide: rootSlide,
+		slide:        rootSlide,
+		keys:         keys,
+		help:         help.New(),
+		rootSlide:    rootSlide,
+		globalTimer:  NewTimer().Start(),
+		timerDisplay: NewTimerDisplay(),
 	}
 }
 
 func (m model) Init() tea.Cmd {
-	return tea.ClearScreen
+	return tea.Batch(
+		tea.ClearScreen,
+		tea.Tick(time.Second, func(time.Time) tea.Msg {
+			return TimerTickMsg{}
+		}),
+	)
 }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -101,7 +134,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		if command.quitting || command.Choice() != nil {
 			if command.Choice() != nil {
-				m.slide = command.Choice()
+				m.navigateToSlide(command.Choice())
 			}
 			m.command = nil
 			return m, nil
@@ -121,7 +154,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					slide = slide.Next
 				}
 				if slide != nil {
-					m.slide = slide
+					m.navigateToSlide(slide)
 				}
 			}
 			m.goTo = nil
@@ -136,17 +169,19 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 		if jump.Quitting() {
 			if steps := jump.JumpSteps(); steps != 0 {
+				newSlide := m.slide
 				if steps > 0 {
 					// Jump forward
-					for i := 0; i < steps && m.slide.Next != nil; i++ {
-						m.slide = m.slide.Next
+					for i := 0; i < steps && newSlide.Next != nil; i++ {
+						newSlide = newSlide.Next
 					}
 				} else {
 					// Jump backward
-					for i := 0; i < -steps && m.slide.Prev != nil; i++ {
-						m.slide = m.slide.Prev
+					for i := 0; i < -steps && newSlide.Prev != nil; i++ {
+						newSlide = newSlide.Prev
 					}
 				}
+				m.navigateToSlide(newSlide)
 			}
 			m.jump = nil
 			return m, nil
@@ -208,18 +243,21 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			jump, cmd := jump.Update(msg)
 			m.jump = &jump
 			return m, cmd
+		} else if key.Matches(msg, m.keys.Timer) {
+			m.timerDisplay = m.timerDisplay.ToggleVisible()
+			return m, nil
 		} else if key.Matches(msg, m.keys.Next) {
 			if m.slide.Next == nil || m.slide.ActiveTransition != nil && m.slide.ActiveTransition.Animating() {
 				return m, nil
 			}
-			m.slide = m.slide.Next
+			m.navigateToSlide(m.slide.Next)
 			m.slide.ActiveTransition = m.slide.Properties.Transition.Start(m.width, m.height, transitions.Forwards)
 			return m, transitions.Animate(transitions.Fps)
 		} else if key.Matches(msg, m.keys.Prev) {
 			if m.slide.Prev == nil || m.slide.ActiveTransition != nil && m.slide.ActiveTransition.Animating() {
 				return m, nil
 			}
-			m.slide = m.slide.Prev
+			m.navigateToSlide(m.slide.Prev)
 			m.slide.ActiveTransition = m.slide.
 				Next.
 				Properties.
@@ -229,16 +267,20 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 
 			return m, transitions.Animate(transitions.Fps)
 		} else if key.Matches(msg, m.keys.Top) {
-			m.slide = m.slide.First()
+			m.navigateToSlide(m.slide.First())
 			return m, nil
 		} else if key.Matches(msg, m.keys.Bottom) {
-			m.slide = m.slide.Last()
+			m.navigateToSlide(m.slide.Last())
 			return m, nil
 		}
 	case transitions.FrameMsg:
 		slide, cmd := m.slide.Update()
 		m.slide = slide
 		return m, cmd
+	case TimerTickMsg:
+		var cmd tea.Cmd
+		m.globalTimer, cmd = m.globalTimer.Update(msg)
+		return m, cmd
 	}
 
 	return m, nil
@@ -267,5 +309,9 @@ func (m model) View() string {
 		return m.jump.Show(slideView, m.width, m.height)
 	}
 
+	if m.timerDisplay.IsVisible() {
+		return m.timerDisplay.Show(slideView, m.width, m.height, m.globalTimer, m.slide.Timer)
+	}
+
 	return slideView
 }