Merge pull request #1457 from rumpl/fix-style-restore

Fix restoring style after style inline text

Author: dgageot

pkg/tui/components/markdown/fast_renderer.go

@@ -75,6 +75,7 @@ type cachedStyles struct {
 	ansiCode     ansiStyle
 	ansiLink     ansiStyle
 	ansiLinkText ansiStyle
+	ansiText     ansiStyle // base document text style
 
 	styleTaskTicked  string
 	styleTaskUntick  string
@@ -95,6 +96,8 @@ func getGlobalStyles() *cachedStyles {
 		styleBold := buildStylePrimitive(mdStyle.Strong)
 		styleItalic := buildStylePrimitive(mdStyle.Emph)
 
+		textStyle := buildStylePrimitive(mdStyle.Document.StylePrimitive)
+
 		globalStyles = &cachedStyles{
 			headingStyles: [6]lipgloss.Style{
 				buildStylePrimitive(mdStyle.H1.StylePrimitive),
@@ -115,6 +118,7 @@ func getGlobalStyles() *cachedStyles {
 			ansiCode:         buildAnsiStyle(buildStylePrimitive(mdStyle.Code.StylePrimitive)),
 			ansiLink:         buildAnsiStyle(buildStylePrimitive(mdStyle.Link)),
 			ansiLinkText:     buildAnsiStyle(buildStylePrimitive(mdStyle.LinkText)),
+			ansiText:         buildAnsiStyle(textStyle),
 			styleTaskTicked:  mdStyle.Task.Ticked,
 			styleTaskUntick:  mdStyle.Task.Unticked,
 			listIndent:       int(mdStyle.List.LevelIndent),
@@ -690,6 +694,7 @@ func (p *parser) renderInline(text string) string {
 	out.Grow(len(text) + 64) // Pre-allocate with extra space for ANSI codes
 	i := 0
 	n := len(text)
+	needsStyleRestore := false // track if we need to restore text style after styled content
 
 	for i < n {
 		// Check for escaped characters
@@ -706,6 +711,7 @@ func (p *parser) renderInline(text string) string {
 				code := text[i+1 : i+1+end]
 				out.WriteString(p.styles.ansiCode.render(code))
 				i = i + 1 + end + 1
+				needsStyleRestore = true
 				continue
 			}
 		}
@@ -724,6 +730,7 @@ func (p *parser) renderInline(text string) string {
 					out.WriteString(p.styles.ansiBold.render(p.renderInline(inner)))
 				}
 				i = i + 2 + end + 2
+				needsStyleRestore = true
 				continue
 			}
 		}
@@ -746,6 +753,7 @@ func (p *parser) renderInline(text string) string {
 				inner := text[i+1 : end]
 				out.WriteString(p.styles.ansiItalic.render(p.renderInline(inner)))
 				i = end + 1
+				needsStyleRestore = true
 				continue
 			}
 		}
@@ -757,6 +765,7 @@ func (p *parser) renderInline(text string) string {
 				inner := text[i+2 : i+2+end]
 				out.WriteString(p.styles.ansiStrike.render(p.renderInline(inner)))
 				i = i + 2 + end + 2
+				needsStyleRestore = true
 				continue
 			}
 		}
@@ -778,14 +787,28 @@ func (p *parser) renderInline(text string) string {
 						out.WriteString(p.styles.ansiLink.render(linkText))
 					}
 					i = i + closeBracket + 2 + closeParen + 1
+					needsStyleRestore = true
 					continue
 				}
 			}
 			fallthrough
 		default:
-			// Regular character
-			out.WriteByte(text[i])
-			i++
+			// Regular character - collect consecutive plain text
+			start := i
+			for i < n && !isInlineMarker(text[i]) {
+				i++
+			}
+			// If we didn't advance (started on an unmatched marker), consume it as literal
+			if i == start {
+				i++
+			}
+			// Only apply text style if we need to restore after styled content
+			if needsStyleRestore {
+				p.styles.ansiText.renderTo(&out, text[start:i])
+				needsStyleRestore = false
+			} else {
+				out.WriteString(text[start:i])
+			}
 		}
 	}
 
@@ -816,14 +839,21 @@ func isWord(b byte) bool {
 // This allows a fast path to skip processing plain text.
 func hasInlineMarkdown(text string) bool {
 	for i := range len(text) {
-		switch text[i] {
-		case '\\', '`', '*', '_', '~', '[':
+		if isInlineMarker(text[i]) {
 			return true
 		}
 	}
 	return false
 }
 
+func isInlineMarker(b byte) bool {
+	switch b {
+	case '\\', '`', '*', '_', '~', '[':
+		return true
+	}
+	return false
+}
+
 // renderCodeBlock renders a fenced code block with syntax highlighting.
 func (p *parser) renderCodeBlock(code, lang string) {
 	if code == "" {

pkg/tui/components/markdown/fast_renderer_test.go

@@ -1,10 +1,12 @@
 package markdown
 
 import (
+	_ "embed"
 	"regexp"
 	"strings"
 	"testing"
 
+	"github.com/charmbracelet/x/ansi"
 	runewidth "github.com/mattn/go-runewidth"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -507,52 +509,46 @@ The fast renderer should handle all of these efficiently.
 
 func BenchmarkFastRenderer(b *testing.B) {
 	r := NewFastRenderer(80)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkInput)
 	}
 }
 
 func BenchmarkGlamourRenderer(b *testing.B) {
 	r := NewGlamourRenderer(80)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkInput)
 	}
 }
 
 func BenchmarkFastRendererSmall(b *testing.B) {
 	r := NewFastRenderer(80)
 	input := "Hello **world**, this is a *test*."
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(input)
 	}
 }
 
 func BenchmarkGlamourRendererSmall(b *testing.B) {
 	r := NewGlamourRenderer(80)
 	input := "Hello **world**, this is a *test*."
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(input)
 	}
 }
 
 func BenchmarkFastRendererCodeBlock(b *testing.B) {
 	r := NewFastRenderer(80)
 	input := "```go\nfunc main() {\n\tfmt.Println(\"hello\")\n}\n```"
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(input)
 	}
 }
 
 func BenchmarkGlamourRendererCodeBlock(b *testing.B) {
 	r := NewGlamourRenderer(80)
-	input := "```go\nfunc main() {\n\tfmt.Println(\"hello\")\n}\n```"
-	b.ResetTimer()
-	for range b.N {
+	input := "```go\nfunc main() {\n\tfmt.Println(\"hello`\")\n}\n```"
+	for b.Loop() {
 		_, _ = r.Render(input)
 	}
 }
@@ -566,48 +562,42 @@ var benchmarkTableInput = `| Name | Age | City | Country | Occupation |
 
 func BenchmarkFastRendererTable(b *testing.B) {
 	r := NewFastRenderer(80)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
 
 func BenchmarkGlamourRendererTable(b *testing.B) {
 	r := NewGlamourRenderer(80)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
 
 func BenchmarkFastRendererTableWidth20(b *testing.B) {
 	r := NewFastRenderer(20)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
 
 func BenchmarkGlamourRendererTableWidth20(b *testing.B) {
 	r := NewGlamourRenderer(20)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
 
 func BenchmarkFastRendererTableWidth200(b *testing.B) {
 	r := NewFastRenderer(200)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
 
 func BenchmarkGlamourRendererTableWidth200(b *testing.B) {
 	r := NewGlamourRenderer(200)
-	b.ResetTimer()
-	for range b.N {
+	for b.Loop() {
 		_, _ = r.Render(benchmarkTableInput)
 	}
 }
@@ -764,3 +754,104 @@ This is a paragraph.
 		})
 	}
 }
+
+func TestInlineCodeRestoresBaseStyle(t *testing.T) {
+	t.Parallel()
+
+	// This test verifies that text after inline code has the document's base style restored,
+	// not just a reset to terminal default.
+	// Bug: "Hello `there` beautiful" - "beautiful" was appearing with terminal default
+	// instead of the document's text color.
+
+	r := NewFastRenderer(80)
+	result, err := r.Render("Hello `there` beautiful")
+	require.NoError(t, err)
+
+	seqs := ansiRegex.FindAllString(result, -1)
+
+	// We should have:
+	// 1. Code style (foreground + background for inline code)
+	// 2. Reset
+	// 3. Base text style restoration (document foreground color)
+	require.GreaterOrEqual(t, len(seqs), 3, "Should have at least 3 ANSI sequences")
+
+	// First sequence should be the code style (has RGB foreground and background)
+	assert.Contains(t, seqs[0], "38;2;", "Code style should have RGB foreground")
+	assert.Contains(t, seqs[0], "48;2;", "Code style should have RGB background")
+
+	// Second sequence should be reset
+	assert.Equal(t, "\x1b[m", seqs[1], "Second sequence should be reset")
+
+	// Third sequence should be the base text style (document color 252)
+	assert.Contains(t, seqs[2], "38;5;252", "Third sequence should restore document text color")
+}
+
+func TestInlineCodeTextContent(t *testing.T) {
+	t.Parallel()
+
+	r := NewFastRenderer(80)
+	result, err := r.Render("Hello `there` beautiful")
+	require.NoError(t, err)
+
+	plain := ansi.Strip(result)
+	require.Contains(t, plain, "Hello there beautiful")
+}
+
+//go:embed testdata/streaming_benchmark.md
+var streamingBenchmarkContent string
+
+// splitIntoStreamingChunks splits content into chunks that simulate LLM streaming.
+// LLM tokens are typically 3-4 characters, so we use small varying chunk sizes.
+func splitIntoStreamingChunks(content string) []string {
+	var chunks []string
+	i := 0
+	chunkSizes := []int{3, 4, 3, 5, 2, 4, 3, 4, 5, 3, 2, 4, 3, 4, 3, 5}
+	sizeIdx := 0
+
+	for i < len(content) {
+		chunkSize := chunkSizes[sizeIdx%len(chunkSizes)]
+		end := i + chunkSize
+		if end > len(content) {
+			end = len(content)
+		}
+		chunks = append(chunks, content[i:end])
+		i = end
+		sizeIdx++
+	}
+	return chunks
+}
+
+// BenchmarkStreamingFastRenderer benchmarks rendering progressively growing markdown.
+// This simulates the streaming use case where content arrives in chunks and
+// the entire accumulated content is re-rendered on each update.
+func BenchmarkStreamingFastRenderer(b *testing.B) {
+	chunks := splitIntoStreamingChunks(streamingBenchmarkContent)
+	r := NewFastRenderer(80)
+
+	b.ResetTimer()
+	for b.Loop() {
+		var accumulated strings.Builder
+		for _, chunk := range chunks {
+			accumulated.WriteString(chunk)
+			_, _ = r.Render(accumulated.String())
+		}
+	}
+}
+
+// BenchmarkStreamingGlamourRenderer benchmarks glamour with progressively growing markdown.
+// Note: glamour's TermRenderer has internal state issues when reused many times,
+// so we create a fresh renderer for each benchmark iteration. This adds overhead
+// but is necessary to avoid panics in glamour's internal ANSI parser.
+func BenchmarkStreamingGlamourRenderer(b *testing.B) {
+	chunks := splitIntoStreamingChunks(streamingBenchmarkContent)
+
+	b.ResetTimer()
+	for b.Loop() {
+		r := NewGlamourRenderer(80)
+		var accumulated strings.Builder
+		for _, chunk := range chunks {
+			accumulated.WriteString(chunk)
+			_, _ = r.Render(accumulated.String())
+		}
+	}
+}