feat(theme): add light/dark theme selection and fix color rendering

- Add Theme field to Settings with SaveTheme helper
- Add first-run theme selector TUI (themeselect package)
- Add theme.Init() that calls lipgloss.SetHasDarkBackground() to ensure
  AdaptiveColor resolves correctly regardless of terminal auto-detection
- Fix all hardcoded colors in tool/ui/styles.go, shared/styles.go,
  render/styles.go to reference theme.CurrentTheme.*
- Remove Faint(true) usage that compounded contrast issues on light bg
- Tune light palette for WCAG AA contrast on white backgrounds
- Remove dead code: ThinkingContentStyle, ToolResultStyle (merged into
  ToolCallStyle), LineContentStyle, IconSearch, unused loader methods

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

Author: yanmxa

internal/app/render/markdown.go

@@ -17,38 +17,54 @@ import (
 
 // MDRenderer renders markdown content to styled terminal output using glamour.
 type MDRenderer struct {
-	renderer *glamour.TermRenderer
-	width    int
+	renderer   *glamour.TermRenderer
+	width      int
+	darkBg     bool // tracks last known terminal background to detect theme changes
 }
 
 // NewMDRenderer creates a new markdown renderer with the given width.
 func NewMDRenderer(width int) *MDRenderer {
 	w := max(width-4, MinWrapWidth)
+	dark := theme.IsDarkBackground()
+	r := buildGlamourRenderer(w, dark)
+	return &MDRenderer{renderer: r, width: w, darkBg: dark}
+}
 
-	// Pick base style based on terminal background
+// buildGlamourRenderer constructs a glamour TermRenderer for the given width and background.
+func buildGlamourRenderer(width int, dark bool) *glamour.TermRenderer {
 	var style ansi.StyleConfig
-	if lipgloss.HasDarkBackground() {
+	if dark {
 		style = styles.DarkStyleConfig
 	} else {
 		style = styles.LightStyleConfig
 	}
-	customizeStyle(&style, w)
+	customizeStyle(&style, width)
 
 	r, err := glamour.NewTermRenderer(
 		glamour.WithStyles(style),
-		glamour.WithWordWrap(w),
+		glamour.WithWordWrap(width),
 		glamour.WithChromaFormatter("terminal256"),
 	)
 	if err != nil {
 		r, _ = glamour.NewTermRenderer(glamour.WithAutoStyle())
 	}
-	return &MDRenderer{renderer: r, width: w}
+	return r
+}
+
+// rebuildIfNeeded recreates the glamour renderer when the terminal background changes.
+func (r *MDRenderer) rebuildIfNeeded() {
+	dark := theme.IsDarkBackground()
+	if dark != r.darkBg {
+		r.renderer = buildGlamourRenderer(r.width, dark)
+		r.darkBg = dark
+	}
 }
 
 // Render parses markdown source and returns styled terminal output.
 // Tables are extracted and rendered with lipgloss/table for full border control,
 // everything else (including code blocks) goes through glamour natively.
 func (r *MDRenderer) Render(content string) (string, error) {
+	r.rebuildIfNeeded()
 	// Normalize paragraph line breaks: LLMs often hard-wrap at ~80 columns,
 	// producing softbreaks that glamour preserves as newlines. Joining them
 	// lets glamour re-wrap at the actual terminal width.
@@ -155,7 +171,7 @@ func (r *MDRenderer) renderTable(content string) string {
 	}
 
 	borderColor := lipgloss.NewStyle().Foreground(theme.CurrentTheme.Separator)
-	headerStyle := lipgloss.NewStyle().Bold(true).Foreground(theme.CurrentTheme.Text)
+	headerStyle := lipgloss.NewStyle().Bold(true).Foreground(theme.CurrentTheme.TextBright)
 
 	t := table.New().
 		Headers(headers...).
@@ -174,7 +190,7 @@ func (r *MDRenderer) renderTable(content string) string {
 			if row == table.HeaderRow {
 				return headerStyle
 			}
-			return lipgloss.NewStyle().Foreground(theme.CurrentTheme.Text)
+			return lipgloss.NewStyle().Foreground(theme.CurrentTheme.TextBright)
 		})
 
 	return "\n" + t.String() + "\n"
@@ -273,11 +289,20 @@ func renderInlineMarkdown(text string) string {
 	return result.String()
 }
 
+// adaptiveColorHex resolves an AdaptiveColor to its hex string based on the
+// current terminal background. Used for glamour StyleConfig which requires *string.
+func adaptiveColorHex(c lipgloss.AdaptiveColor) string {
+	if theme.IsDarkBackground() {
+		return c.Dark
+	}
+	return c.Light
+}
+
 // 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 := string(theme.CurrentTheme.Primary)
-	muted := string(theme.CurrentTheme.Muted)
+	blue := adaptiveColorHex(theme.CurrentTheme.Primary)
+	muted := adaptiveColorHex(theme.CurrentTheme.Muted)
 
 	// Headings: blue, bold, no prefix markers
 	s.H1.Prefix = ""
@@ -384,35 +409,48 @@ func normalizeLineBreaks(content string) string {
 // isMarkdownStructural returns true for lines that start markdown block structures
 // (headers, list items, blockquotes, table rows, thematic breaks).
 func isMarkdownStructural(line string) bool {
+	// Headers
 	if strings.HasPrefix(line, "#") {
 		return true
 	}
+	// Unordered lists
 	if strings.HasPrefix(line, "- ") || strings.HasPrefix(line, "* ") || strings.HasPrefix(line, "+ ") {
 		return true
 	}
+	// Blockquotes
 	if strings.HasPrefix(line, "> ") || line == ">" {
 		return true
 	}
+	// Table rows
 	if strings.HasPrefix(line, "|") {
 		return true
 	}
-	// Thematic break: ---, ***, ___
-	cleaned := strings.ReplaceAll(line, " ", "")
-	if len(cleaned) >= 3 &&
-		(strings.Count(cleaned, "-") == len(cleaned) ||
-			strings.Count(cleaned, "*") == len(cleaned) ||
-			strings.Count(cleaned, "_") == len(cleaned)) {
+	// Thematic breaks (---, ***, ___)
+	if isThematicBreak(line) {
 		return true
 	}
-	// Ordered list: digit(s) + . + space
+	// Ordered lists (digit(s) + . + space)
+	return isOrderedListItem(line)
+}
+
+// isThematicBreak checks if line is a markdown thematic break (---, ***, ___).
+func isThematicBreak(line string) bool {
+	cleaned := strings.ReplaceAll(line, " ", "")
+	if len(cleaned) < 3 {
+		return false
+	}
+	return strings.Count(cleaned, "-") == len(cleaned) ||
+		strings.Count(cleaned, "*") == len(cleaned) ||
+		strings.Count(cleaned, "_") == len(cleaned)
+}
+
+// isOrderedListItem checks if line starts with a numbered list marker (e.g., "1. ").
+func isOrderedListItem(line string) bool {
 	for i, c := range line {
 		if c >= '0' && c <= '9' {
 			continue
 		}
-		if c == '.' && i > 0 && i+1 < len(line) && line[i+1] == ' ' {
-			return true
-		}
-		break
+		return c == '.' && i > 0 && i+1 < len(line) && line[i+1] == ' '
 	}
 	return false
 }

internal/app/render/message.go

@@ -82,7 +82,7 @@ func RenderModeStatus(params OperationModeParams) string {
 // RenderOperationModeIndicator returns the mode status indicator for auto-accept or plan mode.
 func RenderOperationModeIndicator(mode int) string {
 	var icon, label string
-	var color lipgloss.Color
+	var color lipgloss.TerminalColor
 
 	switch appmode.OperationMode(mode) {
 	case appmode.AutoAccept:
@@ -139,17 +139,17 @@ func toolResultIcon(isError bool) string {
 }
 
 // TokenUsageColorAndHint returns the color and hint text for token usage percentage.
-func TokenUsageColorAndHint(percent float64) (lipgloss.Color, string) {
-	switch {
-	case percent >= AutoCompactThreshold:
+func TokenUsageColorAndHint(percent float64) (lipgloss.TerminalColor, string) {
+	if percent >= AutoCompactThreshold {
 		return theme.CurrentTheme.Error, " ⚠ auto-compact"
-	case percent >= 85:
+	}
+	if percent >= 85 {
 		return theme.CurrentTheme.Warning, fmt.Sprintf(" (compact at %d%%)", AutoCompactThreshold)
-	case percent >= 70:
+	}
+	if percent >= 70 {
 		return theme.CurrentTheme.Accent, ""
-	default:
-		return theme.CurrentTheme.Muted, ""
 	}
+	return theme.CurrentTheme.Muted, ""
 }
 
 // RenderUserMessage renders a user message with prompt and optional images.
@@ -243,11 +243,11 @@ func RenderAssistantMessage(params AssistantParams) string {
 		var lines []string
 		for _, line := range strings.Split(wrapped, "\n") {
 			if strings.TrimSpace(line) != "" {
-				lines = append(lines, ThinkingContentStyle.Render(line))
+				lines = append(lines, ThinkingStyle.Render(line))
 			}
 		}
 
-		thinkingIcon := ThinkingContentStyle.Render("✦ ")
+		thinkingIcon := ThinkingStyle.Render("✦ ")
 		thinkingContent := strings.Join(lines, "\n"+aiIndent)
 		sb.WriteString(thinkingIcon + thinkingContent + "\n\n")
 	}
@@ -882,7 +882,6 @@ func FormatAgentLabel(input string) string {
 	return agentType
 }
 
-// ExtractToolArgs extracts the most relevant argument from a tool call input JSON.
 // extractTaskGetDisplay returns owner name for a TaskGet call if available,
 // falling back to the raw task ID.
 func extractTaskGetDisplay(input string, ownerMap map[string]string) string {
@@ -897,6 +896,7 @@ func extractTaskGetDisplay(input string, ownerMap map[string]string) string {
 	return id
 }
 
+// ExtractToolArgs extracts the most relevant argument from a tool call input JSON.
 func ExtractToolArgs(input string) string {
 	var params map[string]any
 	if err := json.Unmarshal([]byte(input), &params); err != nil {
@@ -942,46 +942,61 @@ func ExtractToolArgs(input string) string {
 func FormatToolResultSize(toolName, content string) string {
 	switch toolName {
 	case "WebFetch":
-		size := len(content)
-		if size >= 1024*1024 {
-			return fmt.Sprintf("%.1f MB", float64(size)/(1024*1024))
-		}
-		if size >= 1024 {
-			return fmt.Sprintf("%.1f KB", float64(size)/1024)
-		}
-		return fmt.Sprintf("%d bytes", size)
-
+		return formatByteSize(len(content))
 	case "Write", "Edit":
-		start := strings.Index(content, "(")
-		if start == -1 {
-			return "completed"
-		}
-		end := strings.Index(content[start:], ")")
-		if end == -1 {
-			return "completed"
-		}
-		return content[start+1 : start+end]
+		return extractParenContent(content, "completed")
+	default:
+		return formatLineCount(content)
+	}
+}
 
+// formatByteSize formats a byte count as human-readable size.
+func formatByteSize(size int) string {
+	const (
+		KB = 1024
+		MB = KB * 1024
+	)
+	switch {
+	case size >= MB:
+		return fmt.Sprintf("%.1f MB", float64(size)/MB)
+	case size >= KB:
+		return fmt.Sprintf("%.1f KB", float64(size)/KB)
 	default:
-		trimmed := strings.TrimSuffix(content, "\n")
-		if trimmed == "" {
-			return "0 lines"
-		}
-		lineCount := strings.Count(trimmed, "\n") + 1
-		return fmt.Sprintf("%d lines", lineCount)
+		return fmt.Sprintf("%d bytes", size)
+	}
+}
+
+// extractParenContent extracts content between first ( and ), or returns fallback.
+func extractParenContent(s, fallback string) string {
+	start := strings.Index(s, "(")
+	if start == -1 {
+		return fallback
+	}
+	end := strings.Index(s[start:], ")")
+	if end == -1 {
+		return fallback
 	}
+	return s[start+1 : start+end]
+}
+
+// formatLineCount returns a line count string for the given content.
+func formatLineCount(content string) string {
+	trimmed := strings.TrimSuffix(content, "\n")
+	if trimmed == "" {
+		return "0 lines"
+	}
+	lineCount := strings.Count(trimmed, "\n") + 1
+	return fmt.Sprintf("%d lines", lineCount)
 }
 
 // FormatTokenCount formats a token count for display.
 func FormatTokenCount(count int) string {
-	if count >= 1000000 {
+	switch {
+	case count >= 1000000:
 		return fmt.Sprintf("%.1fM", float64(count)/1000000)
-	}
-	if count >= 10000 {
-		return fmt.Sprintf("%.1fk", float64(count)/1000)
-	}
-	if count >= 1000 {
+	case count >= 1000:
 		return fmt.Sprintf("%.1fk", float64(count)/1000)
+	default:
+		return fmt.Sprintf("%d", count)
 	}
-	return fmt.Sprintf("%d", count)
 }