feat(submit): unwrap hard line breaks in generated PR descriptions

Commit message bodies are typically hard-wrapped at ~72 columns, but
GitHub renders single newlines as `<br>` in PR descriptions, resulting
in ugly narrow paragraphs. `generatePRBody` now unwraps paragraph
lines while preserving markdown structure (code blocks, lists, headers,
blockquotes, tables, horizontal rules). If HTML tags are detected, the
body is left as-is to avoid mangling intentional formatting.

Author: boneskull

cmd/submit.go

@@ -4,6 +4,7 @@ package cmd
 import (
 	"fmt"
 	"os"
+	"regexp"
 	"strings"
 
 	"github.com/boneskull/gh-stack/internal/config"
@@ -514,6 +515,10 @@ func promptMarkPRReady(ghClient *github.Client, prNumber int, branch, trunk stri
 // generatePRBody creates a PR description from the commits between base and head.
 // For a single commit: returns the commit body.
 // For multiple commits: returns each commit as a markdown section.
+//
+// Commit message bodies are unwrapped so that hard line breaks within paragraphs
+// (typical of the ~72-column git convention) are removed. This produces better
+// rendering in GitHub's PR description, which treats single newlines as <br> tags.
 func generatePRBody(g *git.Git, base, head string) (string, error) {
 	commits, err := g.GetCommits(base, head)
 	if err != nil {
@@ -526,7 +531,7 @@ func generatePRBody(g *git.Git, base, head string) (string, error) {
 
 	if len(commits) == 1 {
 		// Single commit: just use the body
-		return commits[0].Body, nil
+		return unwrapParagraphs(commits[0].Body), nil
 	}
 
 	// Multiple commits: format as markdown sections
@@ -540,10 +545,152 @@ func generatePRBody(g *git.Git, base, head string) (string, error) {
 		sb.WriteString("\n")
 		if commit.Body != "" {
 			sb.WriteString("\n")
-			sb.WriteString(commit.Body)
+			sb.WriteString(unwrapParagraphs(commit.Body))
 			sb.WriteString("\n")
 		}
 	}
 
 	return sb.String(), nil
 }
+
+// unwrapParagraphs removes hard line breaks within plain-text paragraphs while
+// preserving intentional structure: blank lines, markdown block-level syntax
+// (headers, lists, blockquotes, horizontal rules), and code blocks (both fenced
+// and indented). This converts the ~72-column convention used in commit messages
+// into flowing text suitable for GitHub's markdown renderer.
+// htmlTagRe matches anything that looks like an HTML tag (e.g. <div>, </span>, <br/>).
+// If we see one anywhere in the text, we bail on unwrapping entirely — anyone writing
+// raw HTML in a commit message is doing something intentional with formatting.
+var htmlTagRe = regexp.MustCompile(`</?[a-zA-Z][a-zA-Z0-9]*[\s/>]`)
+
+// inlineCodeRe matches backtick-enclosed inline code spans so we can strip them
+// before checking for HTML. Otherwise `<token>` in code would trigger a false positive.
+var inlineCodeRe = regexp.MustCompile("`[^`]+`")
+
+func unwrapParagraphs(text string) string {
+	if text == "" {
+		return ""
+	}
+
+	// Bail if the text contains HTML tags — don't mess with it.
+	// Strip inline code spans first so that e.g. `<token>` doesn't false-positive.
+	stripped := inlineCodeRe.ReplaceAllString(text, "")
+	if htmlTagRe.MatchString(stripped) {
+		return text
+	}
+
+	lines := strings.Split(text, "\n")
+	var result []string
+	var paragraph []string
+	inFencedCodeBlock := false
+
+	flushParagraph := func() {
+		if len(paragraph) > 0 {
+			result = append(result, strings.Join(paragraph, " "))
+			paragraph = nil
+		}
+	}
+
+	for _, line := range lines {
+		trimmed := strings.TrimRight(line, " \t")
+
+		// Track fenced code blocks (``` or ~~~)
+		if !inFencedCodeBlock && (strings.HasPrefix(trimmed, "```") || strings.HasPrefix(trimmed, "~~~")) {
+			flushParagraph()
+			result = append(result, line)
+			inFencedCodeBlock = true
+			continue
+		}
+		if inFencedCodeBlock {
+			result = append(result, line)
+			if strings.HasPrefix(trimmed, "```") || strings.HasPrefix(trimmed, "~~~") {
+				inFencedCodeBlock = false
+			}
+			continue
+		}
+
+		// Blank line = paragraph break
+		if trimmed == "" {
+			flushParagraph()
+			result = append(result, "")
+			continue
+		}
+
+		// Preserve lines that are markdown block-level elements
+		if isBlockElement(trimmed) {
+			flushParagraph()
+			result = append(result, line)
+			continue
+		}
+
+		// Indented code block (4+ spaces or tab)
+		if strings.HasPrefix(line, "    ") || strings.HasPrefix(line, "\t") {
+			flushParagraph()
+			result = append(result, line)
+			continue
+		}
+
+		// Otherwise it's a paragraph line — accumulate it
+		paragraph = append(paragraph, trimmed)
+	}
+
+	flushParagraph()
+
+	return strings.Join(result, "\n")
+}
+
+// isBlockElement returns true if the line starts with markdown block-level syntax
+// that should not be joined with adjacent lines.
+func isBlockElement(line string) bool {
+	// Headers
+	if strings.HasPrefix(line, "#") {
+		return true
+	}
+	// Unordered lists
+	if strings.HasPrefix(line, "- ") || strings.HasPrefix(line, "* ") || strings.HasPrefix(line, "+ ") ||
+		line == "-" || line == "*" || line == "+" {
+		return true
+	}
+	// Ordered lists (e.g. "1. ", "12. ")
+	for i, ch := range line {
+		if ch >= '0' && ch <= '9' {
+			continue
+		}
+		if ch == '.' && i > 0 && i+1 < len(line) && line[i+1] == ' ' {
+			return true
+		}
+		break
+	}
+	// Blockquotes
+	if strings.HasPrefix(line, ">") {
+		return true
+	}
+	// Horizontal rules (---, ***, ___)
+	if isHorizontalRule(line) {
+		return true
+	}
+	// Pipe tables
+	if strings.HasPrefix(line, "|") {
+		return true
+	}
+	return false
+}
+
+// isHorizontalRule checks for markdown horizontal rules: three or more
+// -, *, or _ characters (with optional spaces).
+func isHorizontalRule(line string) bool {
+	stripped := strings.ReplaceAll(line, " ", "")
+	if len(stripped) < 3 {
+		return false
+	}
+	ch := stripped[0]
+	if ch != '-' && ch != '*' && ch != '_' {
+		return false
+	}
+	for _, c := range stripped {
+		if byte(c) != ch {
+			return false
+		}
+	}
+	return true
+}

cmd/submit_internal_test.go

@@ -0,0 +1,162 @@
+// cmd/submit_internal_test.go
+package cmd
+
+import (
+	"testing"
+)
+
+func TestUnwrapParagraphs(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "empty string",
+			in:   "",
+			want: "",
+		},
+		{
+			name: "single line",
+			in:   "Hello world",
+			want: "Hello world",
+		},
+		{
+			name: "hard-wrapped paragraph becomes single line",
+			in:   "This is a paragraph that was\nhard-wrapped at around 72 columns\nfor the commit message.",
+			want: "This is a paragraph that was hard-wrapped at around 72 columns for the commit message.",
+		},
+		{
+			name: "blank lines preserved as paragraph breaks",
+			in:   "First paragraph that is\nhard-wrapped.\n\nSecond paragraph also\nhard-wrapped.",
+			want: "First paragraph that is hard-wrapped.\n\nSecond paragraph also hard-wrapped.",
+		},
+		{
+			name: "fenced code block preserved verbatim",
+			in:   "Before code:\n\n```go\nfunc main() {\n    fmt.Println(\"hello\")\n}\n```\n\nAfter code.",
+			want: "Before code:\n\n```go\nfunc main() {\n    fmt.Println(\"hello\")\n}\n```\n\nAfter code.",
+		},
+		{
+			name: "tilde fenced code block preserved",
+			in:   "Text before.\n\n~~~\ncode here\n~~~\n\nText after.",
+			want: "Text before.\n\n~~~\ncode here\n~~~\n\nText after.",
+		},
+		{
+			name: "indented code block preserved",
+			in:   "Some text.\n\n    indented code line 1\n    indented code line 2\n\nMore text.",
+			want: "Some text.\n\n    indented code line 1\n    indented code line 2\n\nMore text.",
+		},
+		{
+			name: "unordered list items preserved",
+			in:   "Changes:\n\n- First item\n- Second item that is\n  also long\n- Third item",
+			// The continuation line (2-space indent) is preserved as-is;
+			// GitHub's markdown renderer already handles this correctly.
+			want: "Changes:\n\n- First item\n- Second item that is\n  also long\n- Third item",
+		},
+		{
+			name: "ordered list items preserved",
+			in:   "Steps:\n\n1. First step\n2. Second step\n3. Third step",
+			want: "Steps:\n\n1. First step\n2. Second step\n3. Third step",
+		},
+		{
+			name: "headers preserved",
+			in:   "## Section\n\nParagraph that is\nhard-wrapped here.\n\n### Subsection\n\nAnother para.",
+			want: "## Section\n\nParagraph that is hard-wrapped here.\n\n### Subsection\n\nAnother para.",
+		},
+		{
+			name: "blockquotes preserved",
+			in:   "> This is a quote\n> that spans lines\n\nRegular text.",
+			want: "> This is a quote\n> that spans lines\n\nRegular text.",
+		},
+		{
+			name: "horizontal rule preserved",
+			in:   "Above\n\n---\n\nBelow",
+			want: "Above\n\n---\n\nBelow",
+		},
+		{
+			name: "realistic commit message body",
+			in:   "This commit refactors the authentication middleware to\nuse JWT tokens instead of session cookies. The change\nimproves scalability by removing server-side session\nstorage requirements.\n\nKey changes:\n\n- Replace session middleware with JWT validation\n- Add token refresh endpoint\n- Update tests to use new auth flow\n\nBreaking change: clients must now send an\n`Authorization: Bearer <token>` header instead of\nrelying on cookies.",
+			want: "This commit refactors the authentication middleware to use JWT tokens instead of session cookies. The change improves scalability by removing server-side session storage requirements.\n\nKey changes:\n\n- Replace session middleware with JWT validation\n- Add token refresh endpoint\n- Update tests to use new auth flow\n\nBreaking change: clients must now send an `Authorization: Bearer <token>` header instead of relying on cookies.",
+		},
+		{
+			name: "pipe tables preserved",
+			in:   "Results:\n\n| Name | Value |\n|------|-------|\n| foo  | 42    |",
+			want: "Results:\n\n| Name | Value |\n|------|-------|\n| foo  | 42    |",
+		},
+		{
+			name: "trailing whitespace on wrapped lines is trimmed",
+			in:   "Line one with trailing space   \nline two.",
+			want: "Line one with trailing space line two.",
+		},
+		{
+			name: "HTML tags cause bail-out",
+			in:   "Some text that is\nhard-wrapped.\n\n<details>\n<summary>Click me</summary>\nHidden content\n</details>",
+			want: "Some text that is\nhard-wrapped.\n\n<details>\n<summary>Click me</summary>\nHidden content\n</details>",
+		},
+		{
+			name: "inline HTML tag causes bail-out",
+			in:   "This has a <br/> in it\nand wraps.",
+			want: "This has a <br/> in it\nand wraps.",
+		},
+		{
+			name: "angle bracket in non-HTML context still unwraps",
+			in:   "The value x < y is\nalways true.",
+			want: "The value x < y is always true.",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := unwrapParagraphs(tt.in)
+			if got != tt.want {
+				t.Errorf("unwrapParagraphs() mismatch\n got: %q\nwant: %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestIsBlockElement(t *testing.T) {
+	blockLines := []string{
+		"# Header",
+		"## Header 2",
+		"- list item",
+		"* list item",
+		"+ list item",
+		"1. ordered",
+		"12. multi-digit ordered",
+		"> blockquote",
+		"| table row",
+	}
+	for _, line := range blockLines {
+		if !isBlockElement(line) {
+			t.Errorf("expected isBlockElement(%q) = true", line)
+		}
+	}
+
+	nonBlockLines := []string{
+		"just text",
+		"This starts a sentence.",
+		"2nd place finish",
+	}
+	for _, line := range nonBlockLines {
+		if isBlockElement(line) {
+			t.Errorf("expected isBlockElement(%q) = false", line)
+		}
+	}
+}
+
+func TestIsHorizontalRule(t *testing.T) {
+	rules := []string{"---", "***", "___", "- - -", "* * *", "----", "****"}
+	for _, r := range rules {
+		if !isHorizontalRule(r) {
+			t.Errorf("expected isHorizontalRule(%q) = true", r)
+		}
+	}
+
+	nonRules := []string{"--", "**", "-", "abc", "---x"}
+	for _, r := range nonRules {
+		if isHorizontalRule(r) {
+			t.Errorf("expected isHorizontalRule(%q) = false", r)
+		}
+	}
+}