Merge pull request #2778 from rumpl/feat-copy-code-blocks

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

Author: rumpl

pkg/tui/components/markdown/codeblock.go

@@ -0,0 +1,18 @@
+package markdown
+
+// CodeBlockCopyIcon 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 CodeBlockCopyIcon = "\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
+// icon 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)
+	ansiCodeBlockCopyIcon ansiStyle    // muted foreground on code block background, used for the per-block copy icon
 
 	// 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),
+			ansiCodeBlockCopyIcon:   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)
+	iconWidth := runewidth.StringWidth(CodeBlockCopyIcon)
+	leftFill := max(availableWidth-paddingRight-iconWidth, 0)
+	if availableWidth >= iconWidth+paddingRight {
+		bgStyle.renderTo(&p.out, spaces(leftFill))
+		p.styles.ansiCodeBlockCopyIcon.renderTo(&p.out, CodeBlockCopyIcon)
+		if paddingRight > 0 {
+			bgStyle.renderTo(&p.out, spaces(paddingRight))
+		}
+	} else {
+		// Too narrow for the icon; 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]), CodeBlockCopyIcon,
+			"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]), CodeBlockCopyIcon)
+	}
+}

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,43 @@ func (r *IncrementalRenderer) joinPrefixAndTail(prefix, tail string) string {
 	return b.String()
 }
 
+// joinSeparatorLines is the number of extra rendered lines that
+// joinPrefixAndTail inserts between the prefix output and the tail output:
+// one to terminate the prefix's final (untrailing-newlined) line, and one
+// blank-padded separator line. Keep this in sync with joinPrefixAndTail.
+const joinSeparatorLines = 2
+
+// mergeCodeBlocks returns the union of code blocks from a cached prefix output
+// and a freshly rendered tail. Tail block line indices are shifted past the
+// prefix's lines and the separator that joinPrefixAndTail inserts.
+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 != "" {
+		offset = strings.Count(prefixOut, "\n") + joinSeparatorLines
+	}
+	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