fix(render): eliminate extra blank lines and Chroma error highlighting

- Override Document.BlockPrefix/BlockSuffix to remove leading empty line
- Clear Heading.BlockSuffix to remove extra blank line after headings
- Add collapseBlankLines post-processor for glamour hardcoded newlines
- Apply TrimLeft to remove leading newlines from first-element blocks
- Remove redundant newline prefixes in View() part composition
- Clear Chroma Error style to prevent red background on tree characters
- Add tests for no-leading-blank-line and no-consecutive-blank-lines

Co-Authored-By: Claude Opus 4 <noreply@anthropic.com>
Signed-off-by: Meng Yan <myan@redhat.com>

Author: yanmxa

cmd/rendercheck/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/yanmxa/gencode/internal/app/render"
+)
+
+func main() {
+	md := render.NewMDRenderer(80)
+
+	tests := []struct {
+		name    string
+		content string
+	}{
+		{"Simple paragraph", "This is a simple paragraph with some text."},
+		{"Two paragraphs", "First paragraph.\n\nSecond paragraph."},
+		{"Heading + paragraph", "## Title\n\nSome content here."},
+		{"List items", "Here are items:\n\n- Item 1\n- Item 2\n- Item 3"},
+		{"Ordered list", "Steps:\n\n1. First step\n2. Second step\n3. Third step"},
+		{"Code block", "Here is code:\n\n```go\nfunc main() {\n    fmt.Println(\"hello\")\n}\n```\n\nAfter code."},
+		{"Inline code", "Use `fmt.Println` to print."},
+		{"Nested list", "- Parent 1\n  - Child 1a\n  - Child 1b\n- Parent 2"},
+		{"Blockquote", "> This is a quote\n> spanning multiple lines"},
+		{"Bold and italic", "This is **bold** and *italic* text."},
+		{"CJK text", "这是一段中文文本，\n用于测试换行效果。"},
+		{"Heading + list + code", "## Summary\n\nKey changes:\n\n- Added `foo` function\n- Fixed bug in `bar`\n\n```go\nfunc foo() {}\n```"},
+		{"Multi heading", "## Section 1\n\nContent 1.\n\n## Section 2\n\nContent 2."},
+		{"List then paragraph", "- Item 1\n- Item 2\n\nSome text after list."},
+		{"Paragraph then list", "Some text before list.\n\n- Item 1\n- Item 2"},
+	}
+
+	for _, tt := range tests {
+		fmt.Printf("=== %s ===\n", tt.name)
+		result, err := md.Render(tt.content)
+		if err != nil {
+			fmt.Printf("ERROR: %v\n", err)
+			continue
+		}
+		lines := strings.Split(result, "\n")
+		for i, line := range lines {
+			fmt.Printf("%2d|%s|\n", i, line)
+		}
+		fmt.Println()
+	}
+}

internal/app/render/markdown.go

@@ -5,6 +5,7 @@ package render
 
 import (
 	"strings"
+	"unicode/utf8"
 
 	"github.com/charmbracelet/glamour"
 	"github.com/charmbracelet/glamour/ansi"
@@ -22,7 +23,10 @@ type MDRenderer struct {
 	darkBg     bool // tracks last known terminal background to detect theme changes
 }
 
-// NewMDRenderer creates a new markdown renderer with the given width.
+// NewMDRenderer creates a new markdown renderer with the given terminal width.
+// The width passed should be the raw terminal column count; the renderer
+// subtracts aiIndentWidth internally so glamour wraps exactly at the
+// visible boundary after the "● " prompt icon + indent are applied.
 func NewMDRenderer(width int) *MDRenderer {
 	w := max(width-4, MinWrapWidth)
 	dark := theme.IsDarkBackground()
@@ -81,12 +85,15 @@ func (r *MDRenderer) Render(content string) (string, error) {
 			if err != nil {
 				parts = append(parts, seg.content)
 			} else {
-				parts = append(parts, strings.TrimRight(rendered, "\n"))
+				rendered = collapseBlankLines(rendered)
+			parts = append(parts, strings.TrimRight(rendered, "\n"))
 			}
 		}
 	}
 
-	return strings.TrimRight(strings.Join(parts, ""), "\n"), nil
+	result := strings.TrimRight(strings.Join(parts, ""), "\n")
+	result = strings.TrimLeft(result, "\n")
+	return result, nil
 }
 
 // segmentKind identifies what type of markdown block a segment contains.
@@ -299,12 +306,20 @@ func adaptiveColorHex(c lipgloss.AdaptiveColor) string {
 }
 
 // customizeStyle adjusts glamour's default style for a clean, unified look.
-// Uses only 3 accent colors: blue (keywords/headings), green (strings/functions), muted (comments).
 func customizeStyle(s *ansi.StyleConfig, width int) {
 	blue := adaptiveColorHex(theme.CurrentTheme.Primary)
 	muted := adaptiveColorHex(theme.CurrentTheme.Muted)
+	text := adaptiveColorHex(theme.CurrentTheme.Text)
+	textDim := adaptiveColorHex(theme.CurrentTheme.TextDim)
 
-	// Headings: blue, bold, no prefix markers
+	// Document: set foreground color, no margin (paragraph spacing handled by glamour block prefix/suffix)
+	margin := uint(0)
+	s.Document.Margin = &margin
+	s.Document.StylePrimitive.Color = &text
+	s.Document.BlockPrefix = ""
+	s.Document.BlockSuffix = ""
+
+	// Headings: themed blue, bold, no extra prefix/suffix markers
 	s.H1.Prefix = ""
 	s.H1.Suffix = ""
 	s.H1.Color = &blue
@@ -316,32 +331,45 @@ func customizeStyle(s *ansi.StyleConfig, width int) {
 	s.H3.Prefix = ""
 	s.H3.Color = &blue
 	s.H3.Bold = boolPtr(true)
+	s.Heading.BlockSuffix = ""
 	s.H4.Prefix = ""
 	s.H5.Prefix = ""
 	s.H6.Prefix = ""
 
+	// BlockQuote: muted color with standard │ indent token
+	s.BlockQuote.StylePrimitive.Color = &textDim
+	s.BlockQuote.Indent = uintPtr(1)
+	s.BlockQuote.IndentToken = stringPtr("│ ")
+
 	// Horizontal rule: full-width thin line
 	hr := strings.Repeat("─", width)
 	s.HorizontalRule.Format = "\n" + hr + "\n"
 	s.HorizontalRule.Color = &muted
 
-	// Inline code: no background, just color distinction
+	// Inline code: no background, accent color
+	accent := adaptiveColorHex(theme.CurrentTheme.Accent)
 	s.Code.StylePrimitive.BackgroundColor = nil
 	s.Code.StylePrimitive.Prefix = ""
 	s.Code.StylePrimitive.Suffix = ""
-	s.Code.StylePrimitive.Color = nil
+	s.Code.StylePrimitive.Color = &accent
 
 	// Code blocks: remove Chroma background color for cleaner look
 	if s.CodeBlock.Chroma != nil {
 		s.CodeBlock.Chroma.Background = ansi.StylePrimitive{}
+		s.CodeBlock.Chroma.Error = ansi.StylePrimitive{}
 	}
-
-	// Reduce document margin for tighter layout
-	margin := uint(0)
-	s.Document.Margin = &margin
 }
 
-func boolPtr(b bool) *bool { return &b }
+func boolPtr(b bool) *bool   { return &b }
+
+func collapseBlankLines(s string) string {
+	for strings.Contains(s, "\n\n\n") {
+		s = strings.ReplaceAll(s, "\n\n\n", "\n\n")
+	}
+	return s
+}
+func uintPtr(u uint) *uint   { return &u }
+func stringPtr(s string) *string { return &s }
 
 // normalizeLineBreaks joins single-newline breaks within plain paragraphs so
 // that glamour's word-wrap can reflow text to the terminal width. Structural
@@ -388,14 +416,18 @@ func normalizeLineBreaks(content string) string {
 		if i > 0 && len(result) > 0 {
 			prev := result[len(result)-1]
 			prevTrimmed := strings.TrimSpace(prev)
-			// Join if previous line is non-blank, non-structural, non-code-fence,
-			// not indented code, and doesn't end with a hard break (two trailing spaces)
 			if prevTrimmed != "" &&
 				!strings.HasPrefix(prevTrimmed, "```") && !strings.HasPrefix(prevTrimmed, "~~~") &&
 				!strings.HasPrefix(prev, "    ") && !strings.HasPrefix(prev, "\t") &&
 				!isMarkdownStructural(prevTrimmed) &&
 				!strings.HasSuffix(prev, "  ") {
-				result[len(result)-1] = prev + " " + trimmed
+				// Don't insert a space between CJK lines — Chinese/Japanese/Korean
+				// text doesn't use spaces between words.
+				sep := " "
+				if endsWithCJK(prevTrimmed) || startsWithCJK(trimmed) {
+					sep = ""
+				}
+				result[len(result)-1] = prev + sep + trimmed
 				continue
 			}
 		}
@@ -454,3 +486,24 @@ func isOrderedListItem(line string) bool {
 	}
 	return false
 }
+
+// isCJK reports whether r is a CJK (Chinese/Japanese/Korean) character.
+func isCJK(r rune) bool {
+	return (r >= 0x4E00 && r <= 0x9FFF) || // CJK Unified Ideographs
+		(r >= 0x3400 && r <= 0x4DBF) || // CJK Extension A
+		(r >= 0x20000 && r <= 0x2A6DF) || // CJK Extension B
+		(r >= 0x3000 && r <= 0x303F) || // CJK Symbols and Punctuation
+		(r >= 0xFF00 && r <= 0xFFEF) // Halfwidth/Fullwidth Forms
+}
+
+// endsWithCJK reports whether s ends with a CJK character.
+func endsWithCJK(s string) bool {
+	r, _ := utf8.DecodeLastRuneInString(s)
+	return r != utf8.RuneError && isCJK(r)
+}
+
+// startsWithCJK reports whether s starts with a CJK character.
+func startsWithCJK(s string) bool {
+	r, _ := utf8.DecodeRuneInString(s)
+	return r != utf8.RuneError && isCJK(r)
+}

internal/app/render/markdown_test.go

@@ -350,3 +350,53 @@ func TestMDRenderer_Table(t *testing.T) {
 		t.Errorf("table should have row separators ─, got:\n%s", plain)
 	}
 }
+
+func TestMDRenderer_NoLeadingBlankLine(t *testing.T) {
+	r := NewMDRenderer(80)
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{"paragraph", "Hello world."},
+		{"heading", "## Title"},
+		{"list", "- item 1\n- item 2"},
+		{"code block", "```go\nfunc main() {}\n```"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out, err := r.Render(tt.input)
+			if err != nil {
+				t.Fatalf("Render error: %v", err)
+			}
+			if strings.HasPrefix(out, "\n") {
+				t.Errorf("output should not start with blank line, got:\n%q", out)
+			}
+		})
+	}
+}
+
+func TestMDRenderer_NoConsecutiveBlankLines(t *testing.T) {
+	r := NewMDRenderer(80)
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{"heading + paragraph", "## Title\n\nSome content here."},
+		{"paragraph + list", "Here are items:\n\n- Item 1\n- Item 2"},
+		{"paragraph + code", "Code:\n\n```go\nfmt.Println(\"hi\")\n```"},
+		{"heading + list", "## Summary\n\n- Item 1\n- Item 2"},
+		{"multi section", "## S1\n\nContent 1.\n\n## S2\n\nContent 2."},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			out, err := r.Render(tt.input)
+			if err != nil {
+				t.Fatalf("Render error: %v", err)
+			}
+			if strings.Contains(out, "\n\n\n") {
+				plain := stripANSI(out)
+				t.Errorf("output should not contain consecutive blank lines, got:\n%s", plain)
+			}
+		})
+	}
+}

internal/app/render/message.go

@@ -153,7 +153,7 @@ func TokenUsageColorAndHint(percent float64) (lipgloss.TerminalColor, string) {
 }
 
 // RenderUserMessage renders a user message with prompt and optional images.
-func RenderUserMessage(content string, images []message.ImageData, mdRenderer *MDRenderer) string {
+func RenderUserMessage(content string, images []message.ImageData, mdRenderer *MDRenderer, width int) string {
 	var sb strings.Builder
 	prompt := InputPromptStyle.Render("❯ ")
 
@@ -166,9 +166,8 @@ func RenderUserMessage(content string, images []message.ImageData, mdRenderer *M
 		sb.WriteString(prompt + strings.Join(parts, " ") + "\n")
 	}
 
-	// Render text content
 	if content != "" {
-		sb.WriteString(prompt + UserMsgStyle.Render(content) + "\n")
+		sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, prompt, UserMsgStyle.Render(content)) + "\n")
 	}
 
 	return sb.String()
@@ -233,30 +232,24 @@ func RenderAssistantMessage(params AssistantParams) string {
 	if params.StreamActive && params.IsLast {
 		aiIcon = AIPromptStyle.Render(params.SpinnerView + " ")
 	}
-	aiIndent := "  "
 
 	// Display thinking content (reasoning_content) if available
 	if params.Thinking != "" {
 		wrapWidth := max(params.Width-2, MinWrapWidth)
 		wrapped := lipgloss.NewStyle().Width(wrapWidth).Render(params.Thinking)
-
 		var lines []string
 		for _, line := range strings.Split(wrapped, "\n") {
 			if strings.TrimSpace(line) != "" {
 				lines = append(lines, ThinkingStyle.Render(line))
 			}
 		}
-
 		thinkingIcon := ThinkingStyle.Render("✦ ")
-		thinkingContent := strings.Join(lines, "\n"+aiIndent)
-		sb.WriteString(thinkingIcon + thinkingContent + "\n\n")
+		sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, thinkingIcon, strings.Join(lines, "\n")) + "\n\n")
 	}
 
-	// Render content based on streaming state
 	content := FormatAssistantContent(params)
 	if content != "" {
-		content = strings.ReplaceAll(content, "\n", "\n"+aiIndent)
-		sb.WriteString(aiIcon + content + "\n")
+		sb.WriteString(lipgloss.JoinHorizontal(lipgloss.Top, aiIcon, content) + "\n")
 	}
 
 	return sb.String()
@@ -345,7 +338,7 @@ func RenderToolCalls(params ToolCallsParams) string {
 			label := FormatAgentLabel(tc.Input)
 			_, hasResult := params.ResultMap[tc.ID]
 			if hasResult {
-				sb.WriteString(ToolCallStyle.Render(fmt.Sprintf("● %s", label)) + "\n")
+				sb.WriteString(renderToolLine(label) + "\n")
 			} else {
 				sb.WriteString(ToolCallStyle.Render(fmt.Sprintf("%s %s", params.SpinnerView, label)))
 				if !params.ToolCallsExpanded {
@@ -359,7 +352,7 @@ func RenderToolCalls(params ToolCallsParams) string {
 				sb.WriteString(formatAgentDefinition(tc.Input))
 			}
 		} else if params.ToolCallsExpanded {
-			toolLine := ToolCallStyle.Render(fmt.Sprintf("● %s", tc.Name))
+			toolLine := renderToolLine(tc.Name)
 			sb.WriteString(toolLine + "\n")
 			var p map[string]any
 			if err := json.Unmarshal([]byte(tc.Input), &p); err == nil {
@@ -376,14 +369,11 @@ func RenderToolCalls(params ToolCallsParams) string {
 			}
 		} else {
 			if tc.Name == tool.ToolTaskGet && params.TaskOwnerMap != nil {
-				// Show owner name instead of raw task ID
 				args := extractTaskGetDisplay(tc.Input, params.TaskOwnerMap)
-				toolLine := ToolCallStyle.Render(fmt.Sprintf("● %s(%s)", tc.Name, args))
-				sb.WriteString(toolLine + "\n")
+				sb.WriteString(renderToolLine(fmt.Sprintf("%s(%s)", tc.Name, args)) + "\n")
 			} else {
 				args := ExtractToolArgs(tc.Input)
-				toolLine := ToolCallStyle.Render(fmt.Sprintf("● %s(%s)", tc.Name, args))
-				sb.WriteString(toolLine + "\n")
+				sb.WriteString(renderToolLine(fmt.Sprintf("%s(%s)", tc.Name, args)) + "\n")
 			}
 		}
 
@@ -1000,3 +990,10 @@ func FormatTokenCount(count int) string {
 		return fmt.Sprintf("%d", count)
 	}
 }
+
+// renderToolLine renders a tool call line with a bullet icon, where continuation
+// lines are automatically indented to align after the icon via JoinHorizontal.
+func renderToolLine(label string) string {
+	icon := ToolCallStyle.Render("● ")
+	return lipgloss.JoinHorizontal(lipgloss.Top, icon, ToolCallStyle.Render(label))
+}

internal/app/view.go

@@ -57,7 +57,7 @@ func (m model) View() string {
 	}
 
 	if todoView != "" {
-		parts = append(parts, "\n"+strings.TrimSuffix(todoView, "\n"))
+		parts = append(parts, strings.TrimSuffix(todoView, "\n"))
 	}
 
 	if pendingImagesView != "" {
@@ -66,12 +66,12 @@ func (m model) View() string {
 
 	if m.provider.FetchingLimits {
 		spinnerView := render.ThinkingStyle.Render(m.output.Spinner.View() + " Fetching token limits...")
-		parts = append(parts, "\n"+spinnerView)
+		parts = append(parts, spinnerView)
 	}
 
 	if m.conv.Compact.Active {
 		spinnerView := render.ThinkingStyle.Render(m.output.Spinner.View() + " Compacting conversation...")
-		parts = append(parts, "\n"+spinnerView)
+		parts = append(parts, spinnerView)
 	}
 
 	chatSection := strings.Join(parts, "\n")
@@ -292,7 +292,7 @@ func (m model) renderMessageRange(startIdx, endIdx int, includeSpinner bool) str
 }
 
 func (m model) renderUserMessage(msg message.ChatMessage) string {
-	return render.RenderUserMessage(msg.Content, msg.Images, m.output.MDRenderer)
+	return render.RenderUserMessage(msg.Content, msg.Images, m.output.MDRenderer, m.width)
 }
 
 func (m model) renderToolResult(msg message.ChatMessage) string {