feat(tui): add per-code-block copy affordance

Each fenced code block now renders a copy glyph in its top-right corner.
Clicking the glyph copies the block's raw content (preserving original
whitespace and line breaks) instead of the whole assistant message.

The renderer returns the list of code blocks alongside the styled output,
and the message click handler maps a click on the glyph back to the
corresponding raw code.

Closes #2776

Author: rumpl

pkg/tui/components/markdown/codeblock.go

@@ -0,0 +1,18 @@
+package markdown
+
+// CodeBlockCopyLabel is the unicode glyph rendered at the top-right corner of
+// every fenced code block. Clicking on it copies the block's raw content to
+// the clipboard. It matches the glyph used for the message-level copy
+// affordance so the visual language stays consistent; the two are
+// disambiguated by line index, not by glyph.
+const CodeBlockCopyLabel = "\u2398"
+
+// CodeBlock describes a fenced code block emitted by the renderer.
+//
+// Line is the 0-indexed line, within the renderer's output, where the copy
+// label is rendered on the code block's top padding row. Content holds the
+// raw code (without ANSI styling) so callers can place it on the clipboard.
+type CodeBlock struct {
+	Content string
+	Line    int
+}

pkg/tui/components/markdown/fast_renderer.go

@@ -117,18 +117,19 @@ type cachedStyles struct {
 	styleCodeBg lipgloss.Style // kept only because chroma styles inherit its bg color
 
 	// ANSI styles (for fast inline rendering)
-	ansiBold       ansiStyle
-	ansiItalic     ansiStyle
-	ansiBoldItal   ansiStyle
-	ansiStrike     ansiStyle
-	ansiCode       ansiStyle
-	ansiLink       ansiStyle
-	ansiLinkText   ansiStyle
-	ansiText       ansiStyle    // base document text style
-	ansiHeadings   [6]ansiStyle // heading styles for inline restoration
-	ansiBlockquote ansiStyle    // blockquote style for inline restoration
-	ansiFootnote   ansiStyle    // footnote reference style
-	ansiCodeBg     ansiStyle    // code block background (cached to avoid repeated buildAnsiStyle)
+	ansiBold        ansiStyle
+	ansiItalic      ansiStyle
+	ansiBoldItal    ansiStyle
+	ansiStrike      ansiStyle
+	ansiCode        ansiStyle
+	ansiLink        ansiStyle
+	ansiLinkText    ansiStyle
+	ansiText        ansiStyle    // base document text style
+	ansiHeadings    [6]ansiStyle // heading styles for inline restoration
+	ansiBlockquote  ansiStyle    // blockquote style for inline restoration
+	ansiFootnote    ansiStyle    // footnote reference style
+	ansiCodeBg      ansiStyle    // code block background (cached to avoid repeated buildAnsiStyle)
+	ansiCodeBgMuted ansiStyle    // muted foreground on code block background (for code-block chrome like copy label)
 
 	// Pre-rendered chrome (computed once, reused across renders)
 	headingPrefixes         [6]string // raw prefix strings (e.g. "## ") for width math
@@ -242,6 +243,7 @@ func getGlobalStyles() *cachedStyles {
 			ansiBlockquote:          buildAnsiStyle(blockquoteLipStyle),
 			ansiFootnote:            buildAnsiStyle(lipgloss.NewStyle().Foreground(styles.TextSecondary).Italic(true)),
 			ansiCodeBg:              buildAnsiStyle(codeBg),
+			ansiCodeBgMuted:         buildAnsiStyle(codeBg.Foreground(styles.TextMutedGray)),
 			headingPrefixes:         headingPrefixes,
 			styledHeadingPrefixes:   styledPrefixes,
 			styledHeadingContIndent: styledContIndents,
@@ -278,27 +280,42 @@ var parserPool = sync.Pool{
 
 // Render parses and renders markdown content to styled terminal output.
 func (r *FastRenderer) Render(input string) (string, error) {
+	out, _, err := r.RenderWithCodeBlocks(input)
+	return out, err
+}
+
+// RenderWithCodeBlocks renders markdown content and returns both the styled
+// terminal output and the list of fenced code blocks emitted, in document
+// order. Each entry's Line points at the rendered line that carries the
+// clickable copy label for that block.
+func (r *FastRenderer) RenderWithCodeBlocks(input string) (string, []CodeBlock, error) {
 	if input == "" {
-		return "", nil
+		return "", nil, nil
 	}
 
 	input = sanitizeForTerminal(input)
 
 	p := parserPool.Get().(*parser)
 	p.reset(input, r.width)
 	result := p.parse()
+	var blocks []CodeBlock
+	if len(p.codeBlocks) > 0 {
+		blocks = make([]CodeBlock, len(p.codeBlocks))
+		copy(blocks, p.codeBlocks)
+	}
 	parserPool.Put(p)
-	return finalizeOutput(result, r.width), nil
+	return finalizeOutput(result, r.width), blocks, nil
 }
 
 // parser holds the state for parsing markdown.
 type parser struct {
-	input   string
-	width   int
-	styles  *cachedStyles
-	out     strings.Builder
-	lines   []string
-	lineIdx int
+	input      string
+	width      int
+	styles     *cachedStyles
+	out        strings.Builder
+	lines      []string
+	lineIdx    int
+	codeBlocks []CodeBlock
 }
 
 func (p *parser) reset(input string, width int) {
@@ -311,6 +328,7 @@ func (p *parser) reset(input string, width int) {
 		p.lines = append(p.lines, line)
 	}
 	p.lineIdx = 0
+	p.codeBlocks = p.codeBlocks[:0]
 	p.out.Reset()
 	p.out.Grow(len(input) * 2) // Pre-allocate for styled output
 }
@@ -1913,10 +1931,25 @@ func (p *parser) renderCodeBlockWithIndent(code, lang, indent string, availableW
 	// Use cached background style
 	bgStyle := p.styles.ansiCodeBg
 
-	// Render empty line at the top (use sequential writes instead of concat)
+	// Render empty line at the top with a copy affordance pushed to the right
+	// edge. Record the rendered line index so click handlers can map a click
+	// back to this block's raw content.
+	topLine := strings.Count(p.out.String(), "\n")
 	p.out.WriteString(indent)
-	bgStyle.renderTo(&p.out, fullWidthPad)
+	labelWidth := runewidth.StringWidth(CodeBlockCopyLabel)
+	leftFill := max(availableWidth-paddingRight-labelWidth, 0)
+	if availableWidth >= labelWidth+paddingRight {
+		bgStyle.renderTo(&p.out, spaces(leftFill))
+		p.styles.ansiCodeBgMuted.renderTo(&p.out, CodeBlockCopyLabel)
+		if paddingRight > 0 {
+			bgStyle.renderTo(&p.out, spaces(paddingRight))
+		}
+	} else {
+		// Too narrow for the label; fall back to a plain top padding row.
+		bgStyle.renderTo(&p.out, fullWidthPad)
+	}
 	p.out.WriteByte('\n')
+	p.codeBlocks = append(p.codeBlocks, CodeBlock{Content: code, Line: topLine})
 
 	// Process tokens line by line for better performance
 	var lineBuilder strings.Builder

pkg/tui/components/markdown/fast_renderer_test.go

@@ -2028,3 +2028,54 @@ func BenchmarkStreamingGlamourRenderer(b *testing.B) {
 		}
 	}
 }
+
+func TestFastRendererCodeBlocksReturnsRawContent(t *testing.T) {
+	t.Parallel()
+
+	input := "Some intro.\n\n```go\npackage main\n\nfunc main() {}\n```\n\nMid.\n\n```\nhello\nworld\n```\n"
+	r := NewFastRenderer(80)
+	out, blocks, err := r.RenderWithCodeBlocks(input)
+	require.NoError(t, err)
+
+	require.Len(t, blocks, 2)
+	assert.Equal(t, "package main\n\nfunc main() {}", blocks[0].Content)
+	assert.Equal(t, "hello\nworld", blocks[1].Content)
+
+	// Each block's recorded line must contain the copy-affordance glyph.
+	lines := strings.Split(out, "\n")
+	for _, b := range blocks {
+		require.Less(t, b.Line, len(lines), "code block line index out of range")
+		assert.Contains(t, stripANSI(lines[b.Line]), CodeBlockCopyLabel,
+			"line %d should contain the code block copy label", b.Line)
+	}
+
+	// The two code blocks must land on different lines.
+	assert.NotEqual(t, blocks[0].Line, blocks[1].Line)
+}
+
+func TestIncrementalRendererCodeBlocksAggregate(t *testing.T) {
+	t.Parallel()
+
+	// Render in two streamed chunks; the second extends the first.
+	chunk1 := "Intro paragraph.\n\n```go\nfunc a() {}\n```\n\n"
+	chunk2 := chunk1 + "Middle.\n\n```\nplain\ncode\n```\n"
+
+	r := NewIncrementalRenderer(80)
+	_, blocks1, err := r.RenderWithCodeBlocks(chunk1)
+	require.NoError(t, err)
+	require.Len(t, blocks1, 1)
+	assert.Equal(t, "func a() {}", blocks1[0].Content)
+
+	out, blocks2, err := r.RenderWithCodeBlocks(chunk2)
+	require.NoError(t, err)
+	require.Len(t, blocks2, 2)
+	assert.Equal(t, "func a() {}", blocks2[0].Content)
+	assert.Equal(t, "plain\ncode", blocks2[1].Content)
+
+	// Each block's reported line must carry the copy label in the final output.
+	lines := strings.Split(out, "\n")
+	for _, b := range blocks2 {
+		require.Less(t, b.Line, len(lines))
+		assert.Contains(t, stripANSI(lines[b.Line]), CodeBlockCopyLabel)
+	}
+}

pkg/tui/components/markdown/incremental.go

@@ -30,6 +30,10 @@ type IncrementalRenderer struct {
 	inputPrefix  string
 	outputPrefix string
 
+	// codeBlocksPrefix is the list of code blocks emitted while rendering the
+	// cached prefix, with Line indices relative to outputPrefix.
+	codeBlocksPrefix []CodeBlock
+
 	// fallback is used for the actual rendering work; it is reused across calls
 	// so its parser pool (and chroma caches) stay warm.
 	fallback *FastRenderer
@@ -48,10 +52,20 @@ func NewIncrementalRenderer(width int) *IncrementalRenderer {
 // inputs that share a long common prefix (the streaming case), only the suffix
 // is parsed and rendered; the rest is served from the cached output.
 func (r *IncrementalRenderer) Render(input string) (string, error) {
+	out, _, err := r.RenderWithCodeBlocks(input)
+	return out, err
+}
+
+// RenderWithCodeBlocks behaves like Render but additionally returns the list
+// of fenced code blocks in the rendered output. Each entry's Line is the
+// 0-indexed line within the returned string where the block's copy label is
+// drawn.
+func (r *IncrementalRenderer) RenderWithCodeBlocks(input string) (string, []CodeBlock, error) {
 	if input == "" {
 		r.inputPrefix = ""
 		r.outputPrefix = ""
-		return "", nil
+		r.codeBlocksPrefix = nil
+		return "", nil, nil
 	}
 
 	// If the new input no longer starts with our cached prefix, the user (or a
@@ -70,33 +84,37 @@ func (r *IncrementalRenderer) Render(input string) (string, error) {
 	if boundary <= 0 {
 		// No new block boundary in the tail yet — render only the tail and
 		// concatenate. Cached prefix is unchanged.
-		renderedTail, err := r.fallback.Render(tail)
+		renderedTail, tailBlocks, err := r.fallback.RenderWithCodeBlocks(tail)
 		if err != nil {
 			return r.fullRender(input)
 		}
-		return r.joinPrefixAndTail(r.outputPrefix, renderedTail), nil
+		out := r.joinPrefixAndTail(r.outputPrefix, renderedTail)
+		return out, r.mergeCodeBlocks(r.outputPrefix, r.codeBlocksPrefix, tailBlocks), nil
 	}
 
 	// We have a new boundary inside the tail. Render the new stable region
 	// (inputPrefix + tail[:boundary]) once, append it to the cache, then render
 	// the new tail.
 	newStableTail := tail[:boundary]
-	renderedStableTail, err := r.fallback.Render(newStableTail)
+	renderedStableTail, stableBlocks, err := r.fallback.RenderWithCodeBlocks(newStableTail)
 	if err != nil {
 		return r.fullRender(input)
 	}
+	newBlocks := r.mergeCodeBlocks(r.outputPrefix, r.codeBlocksPrefix, stableBlocks)
 	r.inputPrefix += newStableTail
 	r.outputPrefix = r.joinPrefixAndTail(r.outputPrefix, renderedStableTail)
+	r.codeBlocksPrefix = newBlocks
 
 	rest := tail[boundary:]
 	if rest == "" {
-		return r.outputPrefix, nil
+		return r.outputPrefix, cloneCodeBlocks(r.codeBlocksPrefix), nil
 	}
-	renderedRest, err := r.fallback.Render(rest)
+	renderedRest, restBlocks, err := r.fallback.RenderWithCodeBlocks(rest)
 	if err != nil {
 		return r.fullRender(input)
 	}
-	return r.joinPrefixAndTail(r.outputPrefix, renderedRest), nil
+	out := r.joinPrefixAndTail(r.outputPrefix, renderedRest)
+	return out, r.mergeCodeBlocks(r.outputPrefix, r.codeBlocksPrefix, restBlocks), nil
 }
 
 // SetWidth updates the renderer width. Width changes invalidate the cache
@@ -109,13 +127,15 @@ func (r *IncrementalRenderer) SetWidth(width int) {
 	r.fallback = NewFastRenderer(width)
 	r.inputPrefix = ""
 	r.outputPrefix = ""
+	r.codeBlocksPrefix = nil
 }
 
 // Reset drops the cached prefix without changing the width. Use when the
 // underlying message is replaced by an unrelated new one.
 func (r *IncrementalRenderer) Reset() {
 	r.inputPrefix = ""
 	r.outputPrefix = ""
+	r.codeBlocksPrefix = nil
 }
 
 // fullRender renders input from scratch, refreshes the cache, and returns the
@@ -124,36 +144,40 @@ func (r *IncrementalRenderer) Reset() {
 // pieces separately, then join. The two render calls on smaller inputs are
 // faster than one big render plus a separate prefix render, and the prefix
 // piece can be reused as outputPrefix.
-func (r *IncrementalRenderer) fullRender(input string) (string, error) {
+func (r *IncrementalRenderer) fullRender(input string) (string, []CodeBlock, error) {
 	boundary := stableBoundary(input)
 	if boundary <= 0 {
-		out, err := r.fallback.Render(input)
+		out, blocks, err := r.fallback.RenderWithCodeBlocks(input)
 		if err != nil {
-			return "", err
+			return "", nil, err
 		}
 		r.inputPrefix = ""
 		r.outputPrefix = ""
-		return out, nil
+		r.codeBlocksPrefix = nil
+		return out, blocks, nil
 	}
 
 	prefix := input[:boundary]
 	rest := input[boundary:]
-	renderedPrefix, err := r.fallback.Render(prefix)
+	renderedPrefix, prefixBlocks, err := r.fallback.RenderWithCodeBlocks(prefix)
 	if err != nil {
-		return "", err
+		return "", nil, err
 	}
 	if rest == "" {
 		r.inputPrefix = prefix
 		r.outputPrefix = renderedPrefix
-		return renderedPrefix, nil
+		r.codeBlocksPrefix = prefixBlocks
+		return renderedPrefix, cloneCodeBlocks(prefixBlocks), nil
 	}
-	renderedRest, err := r.fallback.Render(rest)
+	renderedRest, restBlocks, err := r.fallback.RenderWithCodeBlocks(rest)
 	if err != nil {
-		return "", err
+		return "", nil, err
 	}
 	r.inputPrefix = prefix
 	r.outputPrefix = renderedPrefix
-	return r.joinPrefixAndTail(renderedPrefix, renderedRest), nil
+	r.codeBlocksPrefix = prefixBlocks
+	out := r.joinPrefixAndTail(renderedPrefix, renderedRest)
+	return out, r.mergeCodeBlocks(renderedPrefix, prefixBlocks, restBlocks), nil
 }
 
 // joinPrefixAndTail concatenates a previously rendered prefix and a freshly
@@ -193,6 +217,41 @@ func (r *IncrementalRenderer) joinPrefixAndTail(prefix, tail string) string {
 	return b.String()
 }
 
+// mergeCodeBlocks returns the union of code blocks from a cached prefix output
+// and a freshly rendered tail. Tail block line indices are shifted by the
+// number of lines in the prefix plus one for the blank separator inserted by
+// joinPrefixAndTail.
+func (r *IncrementalRenderer) mergeCodeBlocks(prefixOut string, prefixBlocks, tailBlocks []CodeBlock) []CodeBlock {
+	if len(prefixBlocks) == 0 && len(tailBlocks) == 0 {
+		return nil
+	}
+	out := make([]CodeBlock, 0, len(prefixBlocks)+len(tailBlocks))
+	out = append(out, prefixBlocks...)
+	if len(tailBlocks) == 0 {
+		return out
+	}
+	offset := 0
+	if prefixOut != "" {
+		// Number of lines in prefix (FastRenderer trims its trailing newline so
+		// the count is newlines + 1) plus one for the blank separator inserted
+		// by joinPrefixAndTail.
+		offset = strings.Count(prefixOut, "\n") + 2
+	}
+	for _, b := range tailBlocks {
+		out = append(out, CodeBlock{Content: b.Content, Line: b.Line + offset})
+	}
+	return out
+}
+
+func cloneCodeBlocks(in []CodeBlock) []CodeBlock {
+	if len(in) == 0 {
+		return nil
+	}
+	out := make([]CodeBlock, len(in))
+	copy(out, in)
+	return out
+}
+
 // stableBoundary returns the byte index just after the last "safe" block
 // boundary in input, or 0 if no safe boundary exists. A safe boundary is a
 // blank line that the FastRenderer treats as a hard break between top-level