fix(telegram): prevent code block breakage during message chunking

splitChunks now tracks fenced code blocks and skips paragraph boundaries inside them.
Previously, blank lines inside code blocks could trigger chunk splits, separating
opening and closing fences - breaking MarkdownV2 and forcing plain-text fallback.

3 new tests

Author: molty3000

internal/telegram/format.go

@@ -257,15 +257,61 @@ func convertItalicAndEscape(line string) string {
 }
 
 // splitChunks splits text into chunks no larger than maxBytes bytes.
-// It splits at paragraph boundaries (\n\n) when possible.
+// It splits at paragraph boundaries (\n\n) when possible, but never
+// splits inside fenced code blocks (```), which would break MarkdownV2
+// formatting and cause Telegram parse errors.
 // If a single paragraph exceeds maxBytes, it is split at the last space
 // before the limit.
 func splitChunks(text string, maxBytes int) []string {
 	if maxBytes <= 0 {
 		maxBytes = 4096
 	}
 
-	paragraphs := strings.Split(text, "\n\n")
+	// Walk through the text to find \n\n paragraph boundaries,
+	// but skip \n\n that falls inside fenced code blocks (```).
+	// \n\n inside a code block is kept as part of the block.
+	var paragraphs []string
+	start := 0
+	inCodeBlock := false
+
+	for i := 0; i < len(text); {
+		// Toggle code block state on ``` at the start of a line.
+		if i <= len(text)-3 && text[i:i+3] == "```" {
+			if i == 0 || text[i-1] == '\n' {
+				inCodeBlock = !inCodeBlock
+				i += 3
+				continue
+			}
+		}
+
+		// Look for \n\n paragraph boundary — only split when outside
+		// a code block.
+		if i <= len(text)-2 && text[i:i+2] == "\n\n" && !inCodeBlock {
+			seg := text[start:i]
+			if len(seg) > 0 {
+				paragraphs = append(paragraphs, seg)
+			}
+			i += 2 // skip the \n\n
+			start = i
+			continue
+		}
+		i++
+	}
+
+	// Flush the remaining segment.
+	if start < len(text) {
+		seg := text[start:]
+		if len(seg) > 0 {
+			paragraphs = append(paragraphs, seg)
+		}
+	}
+
+	if len(paragraphs) == 0 {
+		return nil
+	}
+
+	// Now chunk paragraphs. Each paragraph (including code blocks) is
+	// an atomic unit that won't be split at \n\n boundaries.
 	var chunks []string
 	var current strings.Builder
 
@@ -289,7 +335,7 @@ func splitChunks(text string, maxBytes int) []string {
 				chunks = append(chunks, current.String())
 				current.Reset()
 			}
-			// Split the paragraph
+			// Split the paragraph at spaces
 			remaining := p
 			for len(remaining) > 0 {
 				if len(remaining) <= maxBytes {
@@ -323,5 +369,3 @@ func splitChunks(text string, maxBytes int) []string {
 
 	return chunks
 }
-
-

internal/telegram/format_chunk_test.go

@@ -0,0 +1,98 @@
+package telegram
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestSplitChunks_CodeBlockIntact verifies that a code block smaller than
+// maxBytes stays in one chunk — \n\n inside the block doesn't trigger a split.
+func TestSplitChunks_CodeBlockIntact(t *testing.T) {
+	// Code block with internal \n\n — should NOT be split
+	before := strings.Repeat("x", 3500)
+	code := "\n\n```\nsome code\n\ninside block\n```"
+	after := "\n\nfinal text"
+
+	input := before + code + after
+
+	got := splitChunks(input, 4096)
+
+	// The code block must appear BALANCED (even number of ```) in one chunk.
+	// Since the code block fits within 4096, it should be entirely in one chunk.
+	foundComplete := false
+	for _, chunk := range got {
+		opens := strings.Count(chunk, "```")
+		if opens == 2 {
+			// Both open and close in same chunk
+			foundComplete = true
+			if !strings.Contains(chunk, "some code") {
+				t.Error("code block appears intact but content missing")
+			}
+		}
+		if opens == 1 {
+			t.Errorf("unbalanced ``` in chunk (len=%d): %q", len(chunk), chunk[:min(80, len(chunk))])
+		}
+	}
+
+	if !foundComplete {
+		t.Error("no chunk contains the complete code block")
+	}
+
+	// All content must be present
+	combined := strings.Join(got, "")
+	if !strings.Contains(combined, "some code") {
+		t.Error("lost code block content")
+	}
+	if !strings.Contains(combined, "final text") {
+		t.Error("lost after-text content")
+	}
+}
+
+// TestSplitChunks_MultipleCodeBlocks verifies that multiple code blocks
+// are each kept intact during chunking.
+func TestSplitChunks_MultipleCodeBlocks(t *testing.T) {
+	before := strings.Repeat("a", 3000)
+	code1 := "\n\n```go\nfunc main() {}\n```"
+	mid := "\n\n" + strings.Repeat("b", 1000)
+	code2 := "\n\n```json\n{\"key\": \"val\"}\n```"
+
+	input := before + code1 + mid + code2
+
+	got := splitChunks(input, 4096)
+
+	for _, chunk := range got {
+		opens := strings.Count(chunk, "```")
+		if opens%2 != 0 {
+			t.Errorf("unbalanced ``` in chunk: %q", chunk[:min(200, len(chunk))])
+		}
+	}
+
+	combined := strings.Join(got, "")
+	if !strings.Contains(combined, "func main()") {
+		t.Error("lost code1 content")
+	}
+	if !strings.Contains(combined, `"key": "val"`) {
+		t.Error("lost code2 content")
+	}
+}
+
+// TestSplitChunks_InlineCodeUnaffected verifies that inline `code` spans
+// (single backtick) do NOT affect chunk splitting — only fenced blocks.
+func TestSplitChunks_InlineCodeUnaffected(t *testing.T) {
+	before := strings.Repeat("a", 3000)
+	mid := "\n\nUse `code` here."
+	after := "\n\n" + strings.Repeat("b", 2000)
+
+	input := before + mid + after
+
+	got := splitChunks(input, 4096)
+
+	if len(got) < 2 {
+		t.Fatalf("expected at least 2 chunks, got %d", len(got))
+	}
+
+	combined := strings.Join(got, "")
+	if !strings.Contains(combined, "`code`") {
+		t.Error("lost inline code content")
+	}
+}