feat(presentation): add speaker notes mode with sync functionality

- Add `--notes` flag to enable speaker notes mode in `cmd/root.go`
- Add `Notes` field to slide properties configuration in `config/style.go`
- Add `LoadNoOp()` function to disable logging in speaker notes mode
- Create `speaker_notes.go` with dedicated TUI for speaker notes display
- Create `sync_server.go` with TCP server/client for slide synchronization
- Update main TUI to broadcast slide changes to speaker notes clients
- Add automatic reconnection logic when presentation restarts
- Clean up sync server resources on application exit

Author: tharropoulos

cmd/root.go

@@ -23,12 +23,14 @@ var (
 	static     bool
 	configPath string
 	logPath    string
+	notes      bool
 )
 
 func init() {
 	rootCmd.Flags().BoolVarP(&static, "static", "s", false, "Disable live reload (watch mode is enabled by default)")
 	rootCmd.Flags().StringVarP(&configPath, "config", "c", "", "Path to config file")
 	rootCmd.Flags().StringVarP(&logPath, "log", "l", "", "Path to log file (default: ~/.config/kyma/logs/<timestamp>.kyma.log)")
+	rootCmd.Flags().BoolVarP(&notes, "notes", "n", false, "Run in speaker notes mode")
 	rootCmd.AddCommand(versionCmd)
 }
 
@@ -48,8 +50,15 @@ var rootCmd = &cobra.Command{
 		DisableDefaultCmd: true,
 	},
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if err := logger.Load(logPath); err != nil {
-			return fmt.Errorf("failed to initialize slog: %w", err)
+		// Use no-op logger for speaker notes mode, regular logger for main presentation
+		if notes {
+			if err := logger.LoadNoOp(); err != nil {
+				return fmt.Errorf("failed to initialize no-op logger: %w", err)
+			}
+		} else {
+			if err := logger.Load(logPath); err != nil {
+				return fmt.Errorf("failed to initialize slog: %w", err)
+			}
 		}
 
 		slog.Info("Starting Kyma")
@@ -76,7 +85,16 @@ var rootCmd = &cobra.Command{
 
 		slog.Info("Successfully parsed presentation")
 
-		p := tea.NewProgram(tui.New(root), tea.WithAltScreen(), tea.WithMouseAllMotion())
+		if notes {
+			speakerModel := tui.NewSpeakerNotes(root)
+			p := tea.NewProgram(speakerModel, tea.WithAltScreen())
+			if _, err := p.Run(); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		p := tea.NewProgram(tui.New(root, filename), tea.WithAltScreen(), tea.WithMouseAllMotion())
 
 		if !static {
 			slog.Info("Starting file watcher for live reload")

internal/config/style.go

@@ -26,6 +26,7 @@ type Properties struct {
 	Title      string                 `yaml:"title"`
 	Style      StyleConfig            `yaml:"style"`
 	Transition transitions.Transition `yaml:"transition"`
+	Notes      string                 `yaml:"notes"`
 }
 
 type SlideStyle struct {
@@ -217,13 +218,15 @@ func (p *Properties) UnmarshalYAML(bytes []byte) error {
 		Style      StyleConfig `yaml:"style"`
 		Transition string      `yaml:"transition"`
 		Preset     string      `yaml:"preset"`
+		Notes      string      `yaml:"notes"`
 	}{}
 
 	if err := yaml.Unmarshal(bytes, &aux); err != nil {
 		return err
 	}
 
 	p.Title = aux.Title
+	p.Notes = aux.Notes
 
 	if aux.Preset != "" {
 		preset, ok := GlobalConfig.Presets[aux.Preset]

internal/logger/logger.go

@@ -27,6 +27,17 @@ func Load(logPath string) error {
 	return initLogger(logFilePath)
 }
 
+func LoadNoOp() error {
+	handler := slog.NewTextHandler(nil, &slog.HandlerOptions{
+		Level: slog.LevelError + 1,
+	})
+
+	logger := slog.New(handler)
+	slog.SetDefault(logger)
+
+	return nil
+}
+
 func initLogger(logPath string) error {
 	logDir := filepath.Dir(logPath)
 	if err := os.MkdirAll(logDir, 0755); err != nil {

internal/tui/speaker_notes.go

@@ -0,0 +1,225 @@
+package tui
+
+import (
+	"fmt"
+	"log/slog"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/glamour"
+	"github.com/charmbracelet/lipgloss"
+)
+
+// ConnectionStatus represents the state of the sync connection
+type ConnectionStatus int
+
+const (
+	StatusDisconnectedWaiting ConnectionStatus = iota
+	StatusConnected
+	StatusDisconnectedClosed
+	StatusReconnecting
+)
+
+func (s ConnectionStatus) String() string {
+	switch s {
+	case StatusDisconnectedWaiting:
+		return "Disconnected - waiting for presentation to start"
+	case StatusConnected:
+		return "Connected"
+	case StatusDisconnectedClosed:
+		return "Disconnected - presentation closed"
+	case StatusReconnecting:
+		return "Reconnecting..."
+	default:
+		return "Unknown"
+	}
+}
+
+type SpeakerNotesModel struct {
+	width            int
+	height           int
+	currentSlide     int
+	slides           []*Slide
+	syncClient       *SyncClient
+	slideChangeChan  chan int
+	connectionStatus ConnectionStatus
+	reconnecting     bool
+}
+
+type SlideChangeMsg struct {
+	SlideNumber int
+}
+
+type ConnectionLostMsg struct{}
+
+type ReconnectAttemptMsg struct{}
+
+type ReconnectedMsg struct {
+	Client *SyncClient
+}
+
+func NewSpeakerNotes(rootSlide *Slide) SpeakerNotesModel {
+	// Create slides array for easier indexing
+	var slides []*Slide
+	slide := rootSlide
+	for slide != nil {
+		slides = append(slides, slide)
+		slide = slide.Next
+	}
+
+	// Create sync client to connect to the main presentation
+	syncClient, err := NewSyncClient()
+	if err != nil {
+		slog.Warn("Failed to connect to sync server - run the main presentation first", "error", err)
+		syncClient = nil
+	}
+
+	// Create buffered channel for slide changes
+	slideChangeChan := make(chan int, 10)
+
+	return SpeakerNotesModel{
+		currentSlide:     0,
+		slides:           slides,
+		syncClient:       syncClient,
+		slideChangeChan:  slideChangeChan,
+		connectionStatus: StatusConnected,
+		reconnecting:     false,
+	}
+}
+
+func (m SpeakerNotesModel) Init() tea.Cmd {
+	if m.syncClient != nil {
+		// Start listening for slide changes in a goroutine
+		go m.listenForSlideChangesWithReconnect()
+
+		return tea.Batch(
+			tea.ClearScreen,
+			m.waitForSlideChange(),
+		)
+	}
+
+	// No connection initially, start trying to reconnect
+	return tea.Batch(
+		tea.ClearScreen,
+		m.attemptReconnect(),
+	)
+}
+
+func (m SpeakerNotesModel) waitForSlideChange() tea.Cmd {
+	return func() tea.Msg {
+		slideNum := <-m.slideChangeChan
+		return SlideChangeMsg{SlideNumber: slideNum}
+	}
+}
+
+func (m SpeakerNotesModel) listenForSlideChangesWithReconnect() {
+	if m.syncClient == nil {
+		return
+	}
+
+	// Listen for slide changes and detect disconnection
+	m.syncClient.ListenForSlideChanges(m.slideChangeChan)
+
+	// If we reach here, the connection was lost
+	select {
+	case m.slideChangeChan <- -1:
+	default:
+	}
+}
+
+func (m SpeakerNotesModel) attemptReconnect() tea.Cmd {
+	return func() tea.Msg {
+		syncClient, err := NewSyncClient()
+		if err != nil {
+			return ReconnectAttemptMsg{}
+		}
+
+		return ReconnectedMsg{Client: syncClient}
+	}
+}
+
+func (m SpeakerNotesModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width, m.height = msg.Width, msg.Height
+		return m, nil
+	case SlideChangeMsg:
+		if msg.SlideNumber == -1 {
+			m.connectionStatus = StatusDisconnectedClosed
+			if m.syncClient != nil {
+				m.syncClient.Close()
+				m.syncClient = nil
+			}
+			// Start reconnection attempts
+			return m, m.attemptReconnect()
+		}
+
+		if msg.SlideNumber >= 0 && msg.SlideNumber < len(m.slides) {
+			m.currentSlide = msg.SlideNumber
+			slog.Info("Speaker notes: slide changed", "slide", msg.SlideNumber)
+		}
+		// Continue waiting for more slide changes
+		return m, m.waitForSlideChange()
+	case ReconnectAttemptMsg:
+		m.connectionStatus = StatusReconnecting
+		m.reconnecting = true
+		// Wait a bit before trying again
+		return m, tea.Tick(time.Millisecond*200, func(time.Time) tea.Msg {
+			return m.attemptReconnect()()
+		})
+	case ReconnectedMsg:
+		m.syncClient = msg.Client
+		m.connectionStatus = StatusConnected
+		m.reconnecting = false
+		// Start listening for slide changes again
+		go m.listenForSlideChangesWithReconnect()
+		return m, m.waitForSlideChange()
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "q", "esc", "ctrl+c":
+			return m, tea.Quit
+		}
+	}
+
+	return m, nil
+}
+
+func (m SpeakerNotesModel) View() string {
+	if len(m.slides) == 0 {
+		return "No slides available"
+	}
+
+	if m.currentSlide >= len(m.slides) {
+		m.currentSlide = len(m.slides) - 1
+	}
+
+	slide := m.slides[m.currentSlide]
+	notes := slide.Properties.Notes
+
+	if notes == "" {
+		notes = "No speaker notes for this slide."
+	}
+
+	headerText := fmt.Sprintf("Speaker Notes - Slide %d/%d (%s)", m.currentSlide+1, len(m.slides), m.connectionStatus)
+
+	header := lipgloss.NewStyle().
+		Bold(true).
+		Padding(1).
+		Foreground(lipgloss.Color("#9999CC")).
+		Render(headerText)
+
+	rendered, err := glamour.Render(notes, "dark")
+	if err != nil {
+		rendered = notes
+	}
+
+	notesStyle := lipgloss.NewStyle().
+		Padding(2).
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("8")).
+		MarginTop(1)
+
+	content := notesStyle.Render(rendered)
+
+	return lipgloss.JoinVertical(lipgloss.Left, header, content)
+}