feat(tui): add line number support to code highlighting

- Add `ShowLineNumbers` field to `CodeHighlightInfo` struct
- Implement line number rendering with padding and styling
- Add support for `--numbered` flag in markdown code blocks
- Update regex pattern to capture numbered flag from code blocks
- Add tests for line number functionality

Author: tharropoulos

internal/tui/highlight.go

@@ -1,6 +1,7 @@
 package tui
 
 import (
+	"fmt"
 	"regexp"
 	"strconv"
 	"strings"
@@ -20,8 +21,9 @@ type LineRange struct {
 }
 
 type CodeHighlightInfo struct {
-	Language string
-	Ranges   []LineRange
+	Language        string
+	Ranges          []LineRange
+	ShowLineNumbers bool
 }
 
 func parseHighlightSyntax(syntax string) []LineRange {
@@ -88,17 +90,37 @@ func renderWithStyle(content string, info CodeHighlightInfo, lexer chroma.Lexer,
 
 	highlightStyle := lipgloss.NewStyle()
 
+	lineNumberWidth := 0
+	if info.ShowLineNumbers {
+		lineNumberWidth = len(strconv.Itoa(len(lines))) + 2
+	}
+
+	lineNumberStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("240")).
+		PaddingRight(1)
+
 	var result strings.Builder
 	for lineNum, line := range lines {
-		if !shouldHighlightLine(lineNum+1, info.Ranges) {
+		lineNumDisplay := lineNum + 1
+
+		// Add line number if requested
+		if info.ShowLineNumbers {
+			lineNumStr := strconv.Itoa(lineNumDisplay)
+			paddedLineNum := fmt.Sprintf("%*s", lineNumberWidth-1, lineNumStr)
+			result.WriteString(lineNumberStyle.Render(paddedLineNum))
+		}
+
+		shouldHighlight := len(info.Ranges) == 0 || shouldHighlightLine(lineNumDisplay, info.Ranges)
+
+		if !shouldHighlight {
+			// No syntax highlighting for this line
 			result.WriteString(line)
 			if lineNum < len(lines)-1 {
 				result.WriteString("\n")
 			}
 			continue
 		}
 
-		// Handle highlighted lines
 		lineIterator, err := lexer.Tokenise(nil, line)
 		if err != nil {
 			result.WriteString(highlightStyle.Render(line))
@@ -137,7 +159,7 @@ func renderWithStyle(content string, info CodeHighlightInfo, lexer chroma.Lexer,
 }
 
 func processMarkdownWithHighlighting(markdown string, themeName string) (string, error) {
-	re := regexp.MustCompile("(?s)```([a-zA-Z0-9_+-]*)({[^}]*})?\n(.*?)\n```")
+	re := regexp.MustCompile("(?s)```([a-zA-Z0-9_+-]*)({[^}]*})?(\\s+--numbered)?\\s*\n(.*?)\n```")
 
 	matches := re.FindAllStringSubmatch(markdown, -1)
 	if len(matches) == 0 {
@@ -150,7 +172,7 @@ func processMarkdownWithHighlighting(markdown string, themeName string) (string,
 	indices := re.FindAllStringIndex(markdown, -1)
 
 	for i, match := range matches {
-		if len(match) < 4 {
+		if len(match) < 5 {
 			continue
 		}
 
@@ -177,18 +199,20 @@ func processMarkdownWithHighlighting(markdown string, themeName string) (string,
 		if len(match) > 2 && match[2] != "" {
 			highlightSyntax = match[2] // e.g., "{1-2}"
 		}
-		content := match[3] // The actual code content
+		numberedFlag := strings.TrimSpace(match[3]) // " --numbered"
+		content := match[4]                         // The actual code content
 
 		info := CodeHighlightInfo{
-			Language: language,
-			Ranges:   parseHighlightSyntax(highlightSyntax),
+			Language:        language,
+			Ranges:          parseHighlightSyntax(highlightSyntax),
+			ShowLineNumbers: strings.Contains(numberedFlag, "--numbered"),
 		}
 
-		if len(info.Ranges) > 0 {
+		if language != "" || info.ShowLineNumbers {
 			customRendered := renderCustomCodeBlock(content, info, themeName)
 			parts = append(parts, customRendered)
 		} else {
-			// No highlighting ranges, use Glamour directly for the entire code block
+			// No language specified and no line numbers, use Glamour directly for the entire code block
 			codeBlock := match[0]
 			rendered, err := glamour.Render(codeBlock, themeName)
 			if err != nil {

internal/tui/highlight_test.go

@@ -166,6 +166,26 @@ func TestRenderCustomCodeBlock(t *testing.T) {
 			},
 			themeName: "dark",
 		},
+		{
+			name:    "code with line numbers",
+			content: "console.log('hello');\nconsole.log('world');\nvar x = 1;",
+			info: CodeHighlightInfo{
+				Language:        "javascript",
+				Ranges:          []LineRange{{Start: 1, End: 1}},
+				ShowLineNumbers: true,
+			},
+			themeName: "dark",
+		},
+		{
+			name:    "code with only line numbers (no highlighting)",
+			content: "def hello():\n    print('hello')\n    return True",
+			info: CodeHighlightInfo{
+				Language:        "python",
+				Ranges:          nil,
+				ShowLineNumbers: true,
+			},
+			themeName: "dark",
+		},
 	}
 
 	for _, tt := range tests {
@@ -182,6 +202,13 @@ func TestRenderCustomCodeBlock(t *testing.T) {
 				t.Error("renderCustomCodeBlock returned only whitespace")
 			}
 
+			// Check for line numbers if requested
+			if tt.info.ShowLineNumbers {
+				if !strings.Contains(result, "1") {
+					t.Error("renderCustomCodeBlock with ShowLineNumbers should contain line number 1")
+				}
+			}
+
 			// For known languages, check that it contains some recognizable elements
 			if tt.info.Language == "javascript" {
 				if !strings.Contains(result, "console") && !strings.Contains(result, "log") {
@@ -231,6 +258,45 @@ func TestRenderWithStyle(t *testing.T) {
 	}
 }
 
+func TestRenderWithStyleLineNumbers(t *testing.T) {
+	content := "console.log('test');\nvar x = 1;\nfunction hello() {\n  return 'world';\n}"
+	info := CodeHighlightInfo{
+		Language:        "javascript",
+		Ranges:          []LineRange{{Start: 1, End: 2}},
+		ShowLineNumbers: true,
+	}
+
+	lexer := lexers.Get("javascript")
+	if lexer == nil {
+		lexer = lexers.Fallback
+	}
+	lexer = chroma.Coalesce(lexer)
+
+	style := styles.Get("github")
+	if style == nil {
+		style = styles.Fallback
+	}
+
+	result := renderWithStyle(content, info, lexer, style)
+
+	if result == "" {
+		t.Error("renderWithStyle returned empty string")
+	}
+
+	// Should contain line numbers
+	if !strings.Contains(result, "1") {
+		t.Error("renderWithStyle with ShowLineNumbers should contain line number 1")
+	}
+	if !strings.Contains(result, "2") {
+		t.Error("renderWithStyle with ShowLineNumbers should contain line number 2")
+	}
+
+	// Should contain some recognizable elements from the original content
+	if !strings.Contains(result, "console") && !strings.Contains(result, "log") && !strings.Contains(result, "var") {
+		t.Error("renderWithStyle result doesn't contain expected javascript elements")
+	}
+}
+
 func TestProcessMarkdownWithHighlighting(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -274,6 +340,24 @@ func TestProcessMarkdownWithHighlighting(t *testing.T) {
 			theme:    "dark",
 			wantErr:  false,
 		},
+		{
+			name:     "markdown with --numbered flag",
+			markdown: "```javascript --numbered\nconsole.log('hello');\nconsole.log('world');\n```",
+			theme:    "dark",
+			wantErr:  false,
+		},
+		{
+			name:     "markdown with highlighting and --numbered",
+			markdown: "```python{1-2} --numbered\ndef hello():\n    print('hello')\n    return True\n```",
+			theme:    "dark",
+			wantErr:  false,
+		},
+		{
+			name:     "markdown with --numbered and extra spaces",
+			markdown: "```javascript  --numbered  \nconsole.log('test');\nvar x = 1;\n```",
+			theme:    "dark",
+			wantErr:  false,
+		},
 	}
 
 	for _, tt := range tests {
@@ -296,14 +380,22 @@ func TestProcessMarkdownWithHighlighting(t *testing.T) {
 					t.Error("processMarkdownWithHighlighting result seems too short for highlighted content")
 				}
 			}
+
+			// For code blocks with --numbered, should contain line numbers
+			if strings.Contains(tt.markdown, "--numbered") {
+				if !strings.Contains(result, "1") {
+					t.Error("processMarkdownWithHighlighting with --numbered should contain line number 1")
+				}
+			}
 		})
 	}
 }
 
 func TestCodeHighlightInfo(t *testing.T) {
 	info := CodeHighlightInfo{
-		Language: "javascript",
-		Ranges:   []LineRange{{Start: 1, End: 3}, {Start: 5, End: 5}},
+		Language:        "javascript",
+		Ranges:          []LineRange{{Start: 1, End: 3}, {Start: 5, End: 5}},
+		ShowLineNumbers: true,
 	}
 
 	if info.Language != "javascript" {
@@ -318,6 +410,10 @@ func TestCodeHighlightInfo(t *testing.T) {
 		t.Errorf("First range incorrect: got {%d, %d}, expected {1, 3}",
 			info.Ranges[0].Start, info.Ranges[0].End)
 	}
+
+	if !info.ShowLineNumbers {
+		t.Error("Expected ShowLineNumbers to be true")
+	}
 }
 
 func TestLineRange(t *testing.T) {