Merge pull request #1547 from dgageot/tui-refactor

TUI refactor

Author: dgageot

pkg/tui/animation/subscription.go

@@ -0,0 +1,57 @@
+package animation
+
+import tea "charm.land/bubbletea/v2"
+
+// Subscription represents a component's subscription to animation ticks.
+// It encapsulates the registration/unregistration lifecycle, making it
+// easier to manage animation state correctly.
+//
+// Usage:
+//
+//	type MyComponent struct {
+//	    animSub animation.Subscription
+//	}
+//
+//	func (m *MyComponent) Init() tea.Cmd {
+//	    return m.animSub.Start()
+//	}
+//
+//	func (m *MyComponent) Cleanup() {
+//	    m.animSub.Stop()
+//	}
+type Subscription struct {
+	active bool
+}
+
+// Start activates the subscription if not already active.
+// Returns a command to start the tick if this is the first subscription.
+// Safe to call multiple times - only the first call registers.
+func (s *Subscription) Start() tea.Cmd {
+	if s.active {
+		return nil
+	}
+	s.active = true
+	return StartTickIfFirst()
+}
+
+// Stop deactivates the subscription if currently active.
+// Safe to call multiple times - only the first call unregisters.
+func (s *Subscription) Stop() {
+	if !s.active {
+		return
+	}
+	s.active = false
+	Unregister()
+}
+
+// IsActive returns whether the subscription is currently active.
+func (s *Subscription) IsActive() bool {
+	return s.active
+}
+
+// Reset returns a new inactive subscription.
+// Useful when recreating a component that needs fresh animation state.
+func (s *Subscription) Reset() Subscription {
+	s.Stop()
+	return Subscription{}
+}

pkg/tui/cmdbatch/batch.go

@@ -0,0 +1,68 @@
+// Package cmdbatch provides a fluent builder for batching tea.Cmd values.
+//
+// This reduces boilerplate when building command slices in Update functions,
+// following the Elm Architecture pattern of accumulating commands.
+//
+// Usage:
+//
+//	return m, cmdbatch.New().
+//	    Add(p.sidebar.Update(msg)).
+//	    AddIf(p.working, p.spinner.Init()).
+//	    Add(p.messages.Update(msg)).
+//	    Batch()
+package cmdbatch
+
+import tea "charm.land/bubbletea/v2"
+
+// Builder accumulates commands for batching.
+type Builder struct {
+	cmds []tea.Cmd
+}
+
+// New creates a new command builder.
+func New() *Builder {
+	return &Builder{}
+}
+
+// Add appends a command to the batch (nil commands are ignored).
+func (b *Builder) Add(cmd tea.Cmd) *Builder {
+	if cmd != nil {
+		b.cmds = append(b.cmds, cmd)
+	}
+	return b
+}
+
+// AddIf conditionally appends a command to the batch.
+func (b *Builder) AddIf(condition bool, cmd tea.Cmd) *Builder {
+	if condition && cmd != nil {
+		b.cmds = append(b.cmds, cmd)
+	}
+	return b
+}
+
+// AddAll appends multiple commands to the batch.
+func (b *Builder) AddAll(cmds ...tea.Cmd) *Builder {
+	for _, cmd := range cmds {
+		if cmd != nil {
+			b.cmds = append(b.cmds, cmd)
+		}
+	}
+	return b
+}
+
+// Batch returns a batched command, or nil if no commands were added.
+func (b *Builder) Batch() tea.Cmd {
+	switch len(b.cmds) {
+	case 0:
+		return nil
+	case 1:
+		return b.cmds[0]
+	default:
+		return tea.Batch(b.cmds...)
+	}
+}
+
+// Len returns the number of commands in the batch.
+func (b *Builder) Len() int {
+	return len(b.cmds)
+}

pkg/tui/components/sidebar/collapsed_view.go

@@ -0,0 +1,98 @@
+package sidebar
+
+import (
+	"fmt"
+	"strings"
+
+	"charm.land/lipgloss/v2"
+
+	"github.com/docker/cagent/pkg/tui/styles"
+)
+
+// CollapsedViewModel holds the computed layout decisions for collapsed mode.
+// This is a pure data structure - rendering is handled by separate view functions.
+// Computing this once avoids duplicating the layout logic between CollapsedHeight and collapsedView.
+type CollapsedViewModel struct {
+	TitleWithStar    string
+	WorkingIndicator string
+	WorkingDir       string
+	UsageSummary     string
+
+	// Layout decisions computed from the data
+	TitleAndIndicatorOnOneLine bool
+	WdAndUsageOnOneLine        bool
+	ContentWidth               int
+}
+
+// LineCount returns the number of lines needed to render this layout.
+func (vm CollapsedViewModel) LineCount() int {
+	lines := 1 // divider
+
+	switch {
+	case vm.TitleAndIndicatorOnOneLine:
+		lines++
+	case vm.WorkingIndicator == "":
+		// No working indicator but title wraps
+		lines += linesNeeded(lipgloss.Width(vm.TitleWithStar), vm.ContentWidth)
+	default:
+		// Title and working indicator on separate lines, each may wrap
+		lines += linesNeeded(lipgloss.Width(vm.TitleWithStar), vm.ContentWidth)
+		lines += linesNeeded(lipgloss.Width(vm.WorkingIndicator), vm.ContentWidth)
+	}
+
+	if vm.WdAndUsageOnOneLine {
+		lines++
+	} else {
+		lines += linesNeeded(lipgloss.Width(vm.WorkingDir), vm.ContentWidth)
+		if vm.UsageSummary != "" {
+			lines += linesNeeded(lipgloss.Width(vm.UsageSummary), vm.ContentWidth)
+		}
+	}
+
+	return lines
+}
+
+// RenderCollapsedView renders the collapsed sidebar from a CollapsedViewModel.
+// This is a pure function that takes data and returns a string.
+func RenderCollapsedView(vm CollapsedViewModel) string {
+	var lines []string
+
+	// Title line(s)
+	switch {
+	case vm.TitleAndIndicatorOnOneLine:
+		if vm.WorkingIndicator == "" {
+			lines = append(lines, vm.TitleWithStar)
+		} else {
+			gap := vm.ContentWidth - lipgloss.Width(vm.TitleWithStar) - lipgloss.Width(vm.WorkingIndicator)
+			lines = append(lines, fmt.Sprintf("%s%*s%s", vm.TitleWithStar, gap, "", vm.WorkingIndicator))
+		}
+	case vm.WorkingIndicator == "":
+		// No working indicator but title wraps - just output title (lipgloss will wrap)
+		lines = append(lines, vm.TitleWithStar)
+	default:
+		// Title and working indicator on separate lines
+		lines = append(lines, vm.TitleWithStar, vm.WorkingIndicator)
+	}
+
+	// Working directory + usage line(s)
+	if vm.WdAndUsageOnOneLine {
+		gap := vm.ContentWidth - lipgloss.Width(vm.WorkingDir) - lipgloss.Width(vm.UsageSummary)
+		lines = append(lines, fmt.Sprintf("%s%*s%s", styles.MutedStyle.Render(vm.WorkingDir), gap, "", vm.UsageSummary))
+	} else {
+		lines = append(lines, styles.MutedStyle.Render(vm.WorkingDir))
+		if vm.UsageSummary != "" {
+			lines = append(lines, vm.UsageSummary)
+		}
+	}
+
+	return strings.Join(lines, "\n")
+}
+
+// linesNeeded calculates how many lines are needed to display text of given width
+// within a container of contentWidth. Returns at least 1 line.
+func linesNeeded(textWidth, contentWidth int) int {
+	if contentWidth <= 0 || textWidth <= 0 {
+		return 1
+	}
+	return max(1, (textWidth+contentWidth-1)/contentWidth)
+}