⚡ perf: implement O(1) incremental rendering and width-persistent caching

Author: nathfavour

cmd/vibeaura/chat.go

@@ -129,18 +129,23 @@ type model struct {
 	                // Dynamic Commands from Extensions
 	                dynamicCommands map[string]brain.CLICommand
 
-	        		// Non-blocking Engine
-	        		reactor *reactor.Reactor
-	        		md      *reactor.MarkdownRenderer
+	        			// Non-blocking Engine
+	        			reactor *reactor.Reactor
+	        			md      *reactor.MarkdownRenderer
 	        			lastRenderTime time.Time
-	        		}
 
-	        		type layoutMsg struct {
-	        			content     string
-	        			wasAtBottom bool
-	        			wasAtTop    bool
-	        			prevOffset  int
-	        		}
+	        				// Memoization
+	        				lastViewportWidth int
+	        				lastMessageCount  int
+	        					memoizedView      string
+	        				}
+	        				
+	        				type layoutMsg struct {
+	        					content     string
+	        					wasAtBottom bool
+	        					wasAtTop    bool
+	        					prevOffset  int
+	        				}
 type recordTickMsg time.Time
 
 type checkUpdateTickMsg time.Time
@@ -1191,11 +1196,31 @@ func (m *model) renderMessages() string {
 	// Sync renderer width with viewport
 	m.md.SetWidth(m.viewport.Width)
 
-	// Use goroutines to render messages in parallel
-	rendered := make([]string, len(m.messages))
+	// O(1) optimization: If width hasn't changed AND history hasn't changed, return memoized
+	if m.lastViewportWidth == m.viewport.Width && m.lastMessageCount == len(m.messages) && m.memoizedView != "" {
+		return m.memoizedView
+	}
+
+	// O(1) incremental optimization: If width is SAME but messages grew, only render NEW items
+	isIncremental := m.lastViewportWidth == m.viewport.Width && len(m.messages) > m.lastMessageCount && m.memoizedView != ""
+
+	startIndex := 0
+	var sb strings.Builder
+
+	if isIncremental {
+		startIndex = m.lastMessageCount
+		sb.WriteString(m.memoizedView)
+		if startIndex > 0 {
+			sb.WriteString("\n\n")
+		}
+	}
+
+	// Only iterate through what's actually new
+	newMessages := m.messages[startIndex:]
+	rendered := make([]string, len(newMessages))
 	var wg sync.WaitGroup
 
-	for i, msg := range m.messages {
+	for i, msg := range newMessages {
 		wg.Add(1)
 		go func(idx int, raw string) {
 			defer wg.Done()
@@ -1206,7 +1231,8 @@ func (m *model) renderMessages() string {
 				rawContent := strings.TrimPrefix(raw, aiStyle.Render("VibeAuracle: "))
 				// Only render markdown if it's not currently streaming
 				if !strings.HasSuffix(rawContent, subtleStyle.Render("▌")) {
-					content = aiStyle.Render("VibeAuracle:") + "\n" + m.md.Render(rawContent)
+					// Use the width-aware persistent cache (Internal O(1) hit)
+					content = aiStyle.Render("VibeAuracle:") + "\n" + m.md.Render(rawContent, m.viewport.Width)
 				}
 			}
 
@@ -1216,14 +1242,17 @@ func (m *model) renderMessages() string {
 	}
 	wg.Wait()
 
-	var sb strings.Builder
 	for i, r := range rendered {
 		sb.WriteString(r)
 		if i < len(rendered)-1 {
 			sb.WriteString("\n\n")
 		}
 	}
 
+	m.memoizedView = sb.String()
+	m.lastViewportWidth = m.viewport.Width
+	m.lastMessageCount = len(m.messages)
+
 	if m.brain.Config().UI.ShowReasoning {
 		sb.WriteString("\n\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("#5F5F5F")).Bold(true).Render("  ◆ AGENTIC REASONING TRACE") + "\n")
 		for _, log := range m.thinkingLog {

internal/reactor/markdown.go

@@ -7,22 +7,41 @@ import (
 )
 
 type MarkdownRenderer struct {
-	cache sync.Map
-	width int
-	mu    sync.Mutex // Protects width and pool recreation
-	pool  *sync.Pool
+	// width -> content hash -> rendered string
+	caches map[int]*sync.Map
+	pools  map[int]*sync.Pool
+	mu     sync.RWMutex
 }
 
 func NewMarkdownRenderer(width int) *MarkdownRenderer {
 	mr := &MarkdownRenderer{
-		width: width,
+		caches: make(map[int]*sync.Map),
+		pools:  make(map[int]*sync.Pool),
 	}
-	mr.recreatePool(width)
+	mr.getOrCreateResources(width)
 	return mr
 }
 
-func (m *MarkdownRenderer) recreatePool(width int) {
-	m.pool = &sync.Pool{
+func (m *MarkdownRenderer) getOrCreateResources(width int) (*sync.Map, *sync.Pool) {
+	m.mu.RLock()
+	cache, okC := m.caches[width]
+	pool, okP := m.pools[width]
+	m.mu.RUnlock()
+
+	if okC && okP {
+		return cache, pool
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Double check
+	if cache, ok := m.caches[width]; ok {
+		return cache, m.pools[width]
+	}
+
+	newCache := &sync.Map{}
+	newPool := &sync.Pool{
 		New: func() interface{} {
 			r, _ := glamour.NewTermRenderer(
 				glamour.WithAutoStyle(),
@@ -31,36 +50,34 @@ func (m *MarkdownRenderer) recreatePool(width int) {
 			return r
 		},
 	}
+	m.caches[width] = newCache
+	m.pools[width] = newPool
+	return newCache, newPool
 }
 
-func (m *MarkdownRenderer) Render(content string) string {
-	// 1. Concurrent-safe cache check
-	if cached, ok := m.cache.Load(content); ok {
+func (m *MarkdownRenderer) Render(content string, width int) string {
+	cache, pool := m.getOrCreateResources(width)
+
+	// 1. O(1) Cache hit
+	if cached, ok := cache.Load(content); ok {
 		return cached.(string)
 	}
 
-	// 2. Get a renderer from the pool
-	r := m.pool.Get().(*glamour.TermRenderer)
-	defer m.pool.Put(r)
+	// 2. Render only if missed
+	r := pool.Get().(*glamour.TermRenderer)
+	defer pool.Put(r)
 
 	rendered, err := r.Render(content)
 	if err != nil {
 		return content
 	}
 
-	m.cache.Store(content, rendered)
+	cache.Store(content, rendered)
 	return rendered
 }
 
 func (m *MarkdownRenderer) SetWidth(width int) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	if m.width == width {
-		return
-	}
-	m.width = width
-	// Invalidate cache and pool for new width
-	m.cache = sync.Map{}
-	m.recreatePool(width)
+	m.getOrCreateResources(width)
 }
 
+