bodies: choose markdown or org per body !113

merged merged by cmc on 2026-08-30 01:42 UTC · krz/gitbay:org-bodies into main

15 files changed, +472 −178

Layout: unified · split

e2e/issue_test.go +4 −1

 	if code != 0 {
 		t.Fatal("issue show failed")
 	}
+	// A body reports the markup it was written in; "md" is what a body with no
+	// --format carries, and what everything written before formats existed has.
 	wantShow := `{"data":{"assignees":["bob"],"author":"alice","body":"it is broken",` +
-		`"comments":[{"author":"bob","body":"me too","created_at":"TS"}],` +
+		`"body_format":"md",` +
+		`"comments":[{"author":"bob","body":"me too","body_format":"md","created_at":"TS"}],` +
 		`"created_at":"TS","labels":["bug","urgent"],"number":1,"state":"open",` +
 		`"title":"first bug"},"protocol_version":1}`
 	if g := golden(t, out); g != wantShow {

e2e/orgbody_test.go added +83

@@ -0,0 +1,83 @@
	1	package e2e
	2
	3	import (
	4	"strings"
	5	"testing"
	6	)
	7
	8	// A body written in org renders as org, end to end: the format is chosen over
	9	// SSH, stored with the text, and honoured when the page is built. A body
	10	// without a format is markdown, which is what everything written before the
	11	// format existed carries.
	12	func TestOrgBodies(t *testing.T) {
	13	inst := startInstance(t)
	14	aliceKey := inst.newKey(t, "alice")
	15	inst.admin(t, "admin", "user", "create", "alice",
	16	"--key", aliceKey+".pub", "--email", "alice@example.test", "--verified")
	17
	18	if _, errOut, code := inst.ssh(t, aliceKey, "", "repo", "create", "alice/app"); code != 0 {
	19	t.Fatalf("repo create: %s", errOut)
	20	}
	21
	22	const orgBody = "* A heading\n\nSome /emphasis/ and =code= here.\n"
	23
	24	// #1 is org, #2 is the same text left as markdown.
	25	if _, errOut, code := inst.ssh(t, aliceKey, orgBody, "issue", "create", "alice/app",
	26	"--title", "'org issue'", "--file", "-", "--format", "org"); code != 0 {
	27	t.Fatalf("issue create --format org: %s", errOut)
	28	}
	29	if _, errOut, code := inst.ssh(t, aliceKey, orgBody, "issue", "create", "alice/app",
	30	"--title", "'md issue'", "--file", "-"); code != 0 {
	31	t.Fatalf("issue create: %s", errOut)
	32	}
	33
	34	status, body := inst.get(t, "/alice/app/issues/1")
	35	if status != 200 {
	36	t.Fatalf("issue 1: status %d", status)
	37	}
	38	if !strings.Contains(body, "<em>emphasis</em>") \|\| !strings.Contains(body, "<code>code</code>") {
	39	t.Fatalf("org body did not render as org:\n%s", body)
	40	}
	41	// A remark is not a document: no table of contents above two headings.
	42	if strings.Contains(body, `href="#headline-1"`) {
	43	t.Fatalf("org body grew a table of contents:\n%s", body)
	44	}
	45
	46	status, body = inst.get(t, "/alice/app/issues/2")
	47	if status != 200 {
	48	t.Fatalf("issue 2: status %d", status)
	49	}
	50	// Markdown leaves org markup alone; the heading stays literal text.
	51	if strings.Contains(body, "<em>emphasis</em>") {
	52	t.Fatalf("markdown body rendered as org:\n%s", body)
	53	}
	54
	55	// Comments carry their own format, independent of the issue's.
	56	if _, errOut, code := inst.ssh(t, aliceKey, "A /commented/ remark.\n",
	57	"issue", "comment", "alice/app", "2", "--file", "-", "--format", "org"); code != 0 {
	58	t.Fatalf("issue comment --format org: %s", errOut)
	59	}
	60	if status, body = inst.get(t, "/alice/app/issues/2"); status != 200 \|\|
	61	!strings.Contains(body, "<em>commented</em>") {
	62	t.Fatalf("org comment on a markdown issue did not render as org:\n%s", body)
	63	}
	64
	65	// An edit that does not mention a format leaves the stored one alone.
	66	if _, errOut, code := inst.ssh(t, aliceKey, "", "issue", "edit", "alice/app", "1",
	67	"--title", "'org issue, retitled'"); code != 0 {
	68	t.Fatalf("issue edit: %s", errOut)
	69	}
	70	if status, body = inst.get(t, "/alice/app/issues/1"); status != 200 \|\|
	71	!strings.Contains(body, "<em>emphasis</em>") {
	72	t.Fatalf("editing the title dropped the body's org format:\n%s", body)
	73	}
	74
	75	// The format is reported over the API, so other surfaces can honour it.
	76	out, errOut, code := inst.ssh(t, aliceKey, "", "issue", "show", "alice/app", "1", "--json")
	77	if code != 0 {
	78	t.Fatalf("issue show --json: %s", errOut)
	79	}
	80	if !strings.Contains(out, `"body_format":"org"`) {
	81	t.Fatalf("issue show did not report the body format:\n%s", out)
	82	}
	83	}

internal/control/ghimport.go +4 −4

	@@ -184,7 +184,7 @@ func runImportIssues(c *Ctx, args []string) int {
184	return c.fail(protocol.ExitFailure, "%v", err)	184	return c.fail(protocol.ExitFailure, "%v", err)
185	}	185	}
186	body := attribution(src, it.Number, "pull request", it.User.Login, it.CreatedAt) + it.Body	186	body := attribution(src, it.Number, "pull request", it.User.Login, it.CreatedAt) + it.Body
187	localN, err = c.Store.CreateMR(repo.ID, c.User.ID, repo.ID, pr.Head.Ref, pr.Base.Ref, it.Title, body, pr.Head.SHA)	187	localN, err = c.Store.CreateMR(repo.ID, c.User.ID, repo.ID, pr.Head.Ref, pr.Base.Ref, it.Title, body, pr.Head.SHA, "md")
188	if err != nil {	188	if err != nil {
189	return c.fail(protocol.ExitFailure, "%v", err)	189	return c.fail(protocol.ExitFailure, "%v", err)
190	}	190	}
	@@ -206,7 +206,7 @@ func runImportIssues(c *Ctx, args []string) int {
206	mrs++	206	mrs++
207	} else {	207	} else {
208	body := attribution(src, it.Number, "issue", it.User.Login, it.CreatedAt) + it.Body	208	body := attribution(src, it.Number, "issue", it.User.Login, it.CreatedAt) + it.Body
209	localN, err = c.Store.CreateIssue(repo.ID, c.User.ID, it.Title, body)	209	localN, err = c.Store.CreateIssue(repo.ID, c.User.ID, it.Title, body, "md")
210	if err != nil {	210	if err != nil {
211	return c.fail(protocol.ExitFailure, "%v", err)	211	return c.fail(protocol.ExitFailure, "%v", err)
212	}	212	}
	@@ -276,9 +276,9 @@ func importComments(c Ctx, g ghClient, repo store.Repo, from, src string, ghN,
276	body := fmt.Sprintf("> @%s, %s\n\n%s", cm.User.Login, ghDate(cm.CreatedAt), cm.Body)	276	body := fmt.Sprintf("> @%s, %s\n\n%s", cm.User.Login, ghDate(cm.CreatedAt), cm.Body)
277	var err error	277	var err error
278	if isPR {	278	if isPR {
279	err = c.Store.AddMRComment(localMRID, c.User.ID, body)	279	err = c.Store.AddMRComment(localMRID, c.User.ID, body, "md")
280	} else {	280	} else {
281	err = c.Store.AddIssueComment(localIssueID, c.User.ID, body)	281	err = c.Store.AddIssueComment(localIssueID, c.User.ID, body, "md")
282	}	282	}
283	if err != nil {	283	if err != nil {
284	return imported, err	284	return imported, err

internal/control/issue.go +86 −33

 func init() {
 	register(Command{Path: []string{"issue", "create"},
-		Summary:    "open an issue: issue create <owner/name> --title <t> [--body <b> | --file -]",
+		Summary:    "open an issue: issue create <owner/name> --title <t> [--body <b> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runIssueCreate})
 	register(Command{Path: []string{"issue", "list"},
 		Summary: "list issues: issue list <owner/name> [--state open|closed|all] [--limit <n>] [--cursor <c>]", ReadOnly: true, Run: runIssueList})
 	register(Command{Path: []string{"issue", "show"},
 		Summary: "show an issue with comments: issue show <owner/name> <n>", ReadOnly: true, Run: runIssueShow})
 	register(Command{Path: []string{"issue", "edit"},
-		Summary:    "edit title or body: issue edit <owner/name> <n> [--title <t>] [--body <b> | --file -]",
+		Summary:    "edit title or body: issue edit <owner/name> <n> [--title <t>] [--body <b> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runIssueEdit})
 	register(Command{Path: []string{"issue", "comment"},
-		Summary:    "comment: issue comment <owner/name> <n> [--message <m> | --file -]",
+		Summary:    "comment: issue comment <owner/name> <n> [--message <m> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runIssueComment})
 	register(Command{Path: []string{"issue", "close"},
 		Summary: "close an issue: issue close <owner/name> <n>", Run: runIssueClose})
 	return inline, nil
 }
+// markupFormat normalizes a --format value. Empty means the caller did not ask,
+// which the caller turns into "md" on create or "unchanged" on edit.
+func markupFormat(v string) (string, error) {
+	switch strings.ToLower(strings.TrimSpace(v)) {
+	case "":
+		return "", nil
+	case "md", "markdown":
+		return "md", nil
+	case "org", "org-mode":
+		return "org", nil
+	}
+	return "", fmt.Errorf("unknown --format %q (want md or org)", v)
+}
 type issueOut struct {
-	Number    int64    `json:"number"`
+	Number     int64    `json:"number"`
-	Title     string   `json:"title"`
+	Title      string   `json:"title"`
-	State     string   `json:"state"`
+	State      string   `json:"state"`
-	Author    string   `json:"author"`
+	Author     string   `json:"author"`
-	Milestone string   `json:"milestone,omitempty"`
+	Milestone  string   `json:"milestone,omitempty"`
-	Labels    []string `json:"labels,omitempty"`
+	Labels     []string `json:"labels,omitempty"`
-	Assignees []string `json:"assignees,omitempty"`
+	Assignees  []string `json:"assignees,omitempty"`
-	Body      string   `json:"body,omitempty"`
+	Body       string   `json:"body,omitempty"`
-	CreatedAt string   `json:"created_at"`
+	BodyFormat string   `json:"body_format,omitempty"`
+	CreatedAt  string   `json:"created_at"`
 }
 func issueToOut(i store.Issue, withBody bool) issueOut {
 		Milestone: i.Milestone, Labels: i.Labels, Assignees: i.Assignees, CreatedAt: i.CreatedAt}
 	if withBody {
 		o.Body = i.Body
+		o.BodyFormat = i.BodyFormat
 	}
 	return o
 }
 func runIssueCreate(c *Ctx, args []string) int {
-	var path, title, body, file string
+	var path, title, body, file, format string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
+		case "--format":
+			if i+1 >= len(args) {
+				return c.fail(protocol.ExitUsage, "--format requires a value")
+			}
+			format = args[i+1]
+			i++
 		case "--title":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "--title requires a value")
 		}
 	}
 	if path == "" || title == "" {
-		return c.fail(protocol.ExitUsage, "usage: issue create <owner/name> --title <t> [--body <b> | --file -]")
+		return c.fail(protocol.ExitUsage, "usage: issue create <owner/name> --title <t> [--body <b> | --file -] [--format md|org]")
+	}
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if fmtName == "" {
+		fmtName = "md"
 	}
 	// Anyone who can read the repo can file an issue.
 	repo, code := resolveRepo(c, path, policy.CanRead)
 	if err != nil {
 		return c.fail(protocol.ExitUsage, "%v", err)
 	}
-	n, err := c.Store.CreateIssue(repo.ID, c.User.ID, title, b)
+	n, err := c.Store.CreateIssue(repo.ID, c.User.ID, title, b, fmtName)
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	type commentOut struct {
-		Author    string `json:"author"`
+		Author     string `json:"author"`
-		Body      string `json:"body"`
+		Body       string `json:"body"`
-		CreatedAt string `json:"created_at"`
+		BodyFormat string `json:"body_format,omitempty"`
+		CreatedAt  string `json:"created_at"`
 	}
 	var cs []commentOut
 	for _, cm := range comments {
-		cs = append(cs, commentOut{cm.Author, cm.Body, cm.CreatedAt})
+		cs = append(cs, commentOut{cm.Author, cm.Body, cm.BodyFormat, cm.CreatedAt})
 	}
 	d := struct {
 		issueOut
 func runIssueComment(c *Ctx, args []string) int {
 	var rest []string
-	var message, file string
+	var message, file, format string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
+		case "--format":
+			if i+1 >= len(args) {
+				return c.fail(protocol.ExitUsage, "--format requires a value")
+			}
+			format = args[i+1]
+			i++
 		case "--message":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "--message requires a value")
 			rest = append(rest, args[i])
 		}
 	}
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if fmtName == "" {
+		fmtName = "md"
+	}
 	repo, issue, code := issueRef(c, rest, policy.CanRead)
 	if code >= 0 {
 		return code
 	if strings.TrimSpace(body) == "" {
 		return c.fail(protocol.ExitUsage, "empty comment; use --message or --file -")
 	}
-	if err := c.Store.AddIssueComment(issue.ID, c.User.ID, body); err != nil {
+	if err := c.Store.AddIssueComment(issue.ID, c.User.ID, body, fmtName); err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	c.Store.RecordEvent(repo.ID, c.User.ID, "issue.commented", fmt.Sprintf(`{"number":%d}`, issue.Number))
 	})
 }
-// editText parses --title/--body/--file - and authorizes: author or write.
+// editText parses --title/--body/--file -/--format and authorizes: author or
-func editText(c *Ctx, args []string, kind string) (rest []string, title, body *string, code int) {
+// write. A nil format means the stored markup format stays as it is.
-	var titleV, bodyV, file string
+func editText(c *Ctx, args []string, kind string) (rest []string, title, body, format *string, code int) {
+	var titleV, bodyV, file, formatV string
 	haveTitle, haveBody := false, false
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--title", "--body", "--file":
+		case "--title", "--body", "--file", "--format":
 			if i+1 >= len(args) {
-				return nil, nil, nil, c.fail(protocol.ExitUsage, "%s requires a value", args[i])
+				return nil, nil, nil, nil, c.fail(protocol.ExitUsage, "%s requires a value", args[i])
 			}
 			switch args[i] {
 			case "--title":
 				bodyV, haveBody = args[i+1], true
 			case "--file":
 				file = args[i+1]
+			case "--format":
+				formatV = args[i+1]
 			}
 			i++
 		default:
 	if file != "" {
 		b, err := bodyFrom(c, "", file)
 		if err != nil {
-			return nil, nil, nil, c.fail(protocol.ExitUsage, "%v", err)
+			return nil, nil, nil, nil, c.fail(protocol.ExitUsage, "%v", err)
 		}
 		bodyV, haveBody = b, true
 	}
-	if !haveTitle && !haveBody {
+	fmtName, err := markupFormat(formatV)
-		return nil, nil, nil, c.fail(protocol.ExitUsage, "usage: %s edit <owner/name> <n> [--title <t>] [--body <b> | --file -]", kind)
+	if err != nil {
+		return nil, nil, nil, nil, c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if !haveTitle && !haveBody && fmtName == "" {
+		return nil, nil, nil, nil, c.fail(protocol.ExitUsage, "usage: %s edit <owner/name> <n> [--title <t>] [--body <b> | --file -] [--format md|org]", kind)
 	}
 	if haveTitle {
 		if strings.TrimSpace(titleV) == "" {
-			return nil, nil, nil, c.fail(protocol.ExitUsage, "--title must not be empty")
+			return nil, nil, nil, nil, c.fail(protocol.ExitUsage, "--title must not be empty")
 		}
 		title = &titleV
 	}
 	if haveBody {
 		body = &bodyV
 	}
-	return rest, title, body, -1
+	if fmtName != "" {
+		format = &fmtName
+	}
+	return rest, title, body, format, -1
 }
 func runIssueEdit(c *Ctx, args []string) int {
-	rest, title, body, code := editText(c, args, "issue")
+	rest, title, body, format, code := editText(c, args, "issue")
 	if code >= 0 {
 		return code
 	}
 	if issue.Author != c.User.Username && !policy.CanWrite(c.User, repo, grant) {
 		return c.fail(protocol.ExitDenied, "only the author or users with write access can edit this issue")
 	}
-	if err := c.Store.UpdateIssueText(issue.ID, title, body); err != nil {
+	if err := c.Store.UpdateIssueText(issue.ID, title, body, format); err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	return c.emit(map[string]any{"number": issue.Number}, func(w io.Writer) {

internal/control/migrate.go +4 −4

	@@ -227,7 +227,7 @@ func runAccountImportBundle(c *Ctx, args []string) int {
227	continue	227	continue
228	}	228	}
229	body := migAttribution(src, "issue", bi.Author, bi.CreatedAt, bi.Number) + bi.Body	229	body := migAttribution(src, "issue", bi.Author, bi.CreatedAt, bi.Number) + bi.Body
230	n, err := c.Store.CreateIssue(repo.ID, c.User.ID, bi.Title, body)	230	n, err := c.Store.CreateIssue(repo.ID, c.User.ID, bi.Title, body, "md")
231	if err != nil {	231	if err != nil {
232	return c.fail(protocol.ExitFailure, "%v", err)	232	return c.fail(protocol.ExitFailure, "%v", err)
233	}	233	}
	@@ -243,7 +243,7 @@ func runAccountImportBundle(c *Ctx, args []string) int {
243	}	243	}
244	for _, cm := range bi.Comments {	244	for _, cm := range bi.Comments {
245	c.Store.AddIssueComment(iss.ID, c.User.ID,	245	c.Store.AddIssueComment(iss.ID, c.User.ID,
246	fmt.Sprintf("> %s, %.10s\n\n%s", cm.Author, cm.CreatedAt, cm.Body))	246	fmt.Sprintf("> %s, %.10s\n\n%s", cm.Author, cm.CreatedAt, cm.Body), "md")
247	comments++	247	comments++
248	}	248	}
249	c.Store.SetImportMarker(repo.ID, key, fmt.Sprint(n))	249	c.Store.SetImportMarker(repo.ID, key, fmt.Sprint(n))
	@@ -256,7 +256,7 @@ func runAccountImportBundle(c *Ctx, args []string) int {
256	continue	256	continue
257	}	257	}
258	body := migAttribution(src, "merge request", bm.Author, bm.CreatedAt, bm.Number) + bm.Body	258	body := migAttribution(src, "merge request", bm.Author, bm.CreatedAt, bm.Number) + bm.Body
259	n, err := c.Store.CreateMR(repo.ID, c.User.ID, repo.ID, bm.SourceRef, bm.TargetRef, bm.Title, body, "")	259	n, err := c.Store.CreateMR(repo.ID, c.User.ID, repo.ID, bm.SourceRef, bm.TargetRef, bm.Title, body, "", "md")
260	if err != nil {	260	if err != nil {
261	return c.fail(protocol.ExitFailure, "%v", err)	261	return c.fail(protocol.ExitFailure, "%v", err)
262	}	262	}
	@@ -273,7 +273,7 @@ func runAccountImportBundle(c *Ctx, args []string) int {
273	}	273	}
274	for _, cm := range bm.Comments {	274	for _, cm := range bm.Comments {
275	c.Store.AddMRComment(mr.ID, c.User.ID,	275	c.Store.AddMRComment(mr.ID, c.User.ID,
276	fmt.Sprintf("> %s, %.10s\n\n%s", cm.Author, cm.CreatedAt, cm.Body))	276	fmt.Sprintf("> %s, %.10s\n\n%s", cm.Author, cm.CreatedAt, cm.Body), "md")
277	comments++	277	comments++
278	}	278	}
279	c.Store.SetImportMarker(repo.ID, key, fmt.Sprint(n))	279	c.Store.SetImportMarker(repo.ID, key, fmt.Sprint(n))

internal/control/mr.go +49 −27

 	register(Command{Path: []string{"repo", "settings", "require-signed"},
 		Summary: "require verified commit signatures: repo settings require-signed <owner/name> on|off", Run: runRequireSigned})
 	register(Command{Path: []string{"mr", "create"},
-		Summary:    "open a merge request: mr create <target owner/name> --source [owner/name:]<branch> --target <branch> --title <t> [--body <b> | --file -]",
+		Summary:    "open a merge request: mr create <target owner/name> --source [owner/name:]<branch> --target <branch> --title <t> [--body <b> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runMRCreate})
 	register(Command{Path: []string{"mr", "list"},
 		Summary: "list merge requests: mr list <owner/name> [--state open|merged|closed|source_gone|all] [--limit <n>] [--cursor <c>]", ReadOnly: true, Run: runMRList})
 	register(Command{Path: []string{"mr", "diff"},
 		Summary: "show the diff: mr diff <owner/name> <n>", ReadOnly: true, Run: runMRDiff})
 	register(Command{Path: []string{"mr", "edit"},
-		Summary:    "edit title or body: mr edit <owner/name> <n> [--title <t>] [--body <b> | --file -]",
+		Summary:    "edit title or body: mr edit <owner/name> <n> [--title <t>] [--body <b> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runMREdit})
 	register(Command{Path: []string{"mr", "comment"},
-		Summary:    "comment: mr comment <owner/name> <n> [--message <m> | --file -]",
+		Summary:    "comment: mr comment <owner/name> <n> [--message <m> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runMRComment})
 	register(Command{Path: []string{"mr", "review"},
 		Summary: "review: mr review <owner/name> <n> --approve|--request-changes|--comment", Run: runMRReview})
 func mrHeadRef(n int64) string { return fmt.Sprintf("refs/merge-requests/%d/head", n) }
 func runMRCreate(c *Ctx, args []string) int {
-	var path, source, target, title, body, file string
+	var path, source, target, title, body, file, format string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--source", "--target", "--title", "--body", "--file":
+		case "--source", "--target", "--title", "--body", "--file", "--format":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "%s requires a value", args[i])
 			}
 				body = v
 			case "--file":
 				file = v
+			case "--format":
+				format = v
 			}
 			i++
 		default:
 	if path == "" || source == "" || title == "" {
 		return c.fail(protocol.ExitUsage, "usage: mr create <target owner/name> --source [owner/name:]<branch> --target <branch> --title <t>")
 	}
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if fmtName == "" {
+		fmtName = "md"
+	}
 	repo, code := resolveRepo(c, path, policy.CanRead)
 	if code >= 0 {
 		return code
 	if err != nil {
 		return c.fail(protocol.ExitUsage, "%v", err)
 	}
-	n, err := c.Store.CreateMR(repo.ID, c.User.ID, srcRepo.ID, srcBranch, target, title, b, headSHA)
+	n, err := c.Store.CreateMR(repo.ID, c.User.ID, srcRepo.ID, srcBranch, target, title, b, headSHA, fmtName)
 	if err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 }
 type mrOut struct {
-	Number    int64  `json:"number"`
+	Number     int64  `json:"number"`
-	Title     string `json:"title"`
+	Title      string `json:"title"`
-	State     string `json:"state"`
+	State      string `json:"state"`
-	Author    string `json:"author"`
+	Author     string `json:"author"`
-	Source    string `json:"source"` // owner/name:branch, or branch, "" if gone
+	Source     string `json:"source"` // owner/name:branch, or branch, "" if gone
-	TargetRef string `json:"target_ref"`
+	TargetRef  string `json:"target_ref"`
-	HeadSHA   string `json:"head_sha"`
+	HeadSHA    string `json:"head_sha"`
-	Body      string `json:"body,omitempty"`
+	Body       string `json:"body,omitempty"`
-	Milestone string `json:"milestone,omitempty"`
+	BodyFormat string `json:"body_format,omitempty"`
-	CreatedAt string `json:"created_at"`
+	Milestone  string `json:"milestone,omitempty"`
+	CreatedAt  string `json:"created_at"`
 }
 func mrToOut(repo store.Repo, m store.MR, withBody bool) mrOut {
 		CreatedAt: m.CreatedAt}
 	if withBody {
 		o.Body = m.Body
+		o.BodyFormat = m.BodyFormat
 	}
 	return o
 }
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	type commentOut struct {
-		Author    string `json:"author"`
+		Author     string `json:"author"`
-		Body      string `json:"body"`
+		Body       string `json:"body"`
-		CreatedAt string `json:"created_at"`
+		BodyFormat string `json:"body_format,omitempty"`
+		CreatedAt  string `json:"created_at"`
 	}
 	type reviewOut struct {
 		Reviewer string `json:"reviewer"`
 	}
 	var cs []commentOut
 	for _, cm := range comments {
-		cs = append(cs, commentOut{cm.Author, cm.Body, cm.CreatedAt})
+		cs = append(cs, commentOut{cm.Author, cm.Body, cm.BodyFormat, cm.CreatedAt})
 	}
 	var rs []reviewOut
 	for _, r := range reviews {
 }
 func runMREdit(c *Ctx, args []string) int {
-	rest, title, body, code := editText(c, args, "mr")
+	rest, title, body, format, code := editText(c, args, "mr")
 	if code >= 0 {
 		return code
 	}
 	if mr.Author != c.User.Username && !policy.CanWrite(c.User, repo, grant) {
 		return c.fail(protocol.ExitDenied, "only the author or users with write access can edit this merge request")
 	}
-	if err := c.Store.UpdateMRText(mr.ID, title, body); err != nil {
+	if err := c.Store.UpdateMRText(mr.ID, title, body, format); err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	return c.emit(map[string]any{"number": mr.Number}, func(w io.Writer) {
 func runMRComment(c *Ctx, args []string) int {
 	var rest []string
-	var message, file string
+	var message, file, format string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--message", "--file":
+		case "--message", "--file", "--format":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "%s requires a value", args[i])
 			}
-			if args[i] == "--message" {
+			switch args[i] {
+			case "--message":
 				message = args[i+1]
-			} else {
+			case "--file":
 				file = args[i+1]
+			case "--format":
+				format = args[i+1]
 			}
 			i++
 		default:
 			rest = append(rest, args[i])
 		}
 	}
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if fmtName == "" {
+		fmtName = "md"
+	}
 	repo, mr, code := mrRef(c, rest, policy.CanRead)
 	if code >= 0 {
 		return code
 	if strings.TrimSpace(body) == "" {
 		return c.fail(protocol.ExitUsage, "empty comment; use --message or --file -")
 	}
-	if err := c.Store.AddMRComment(mr.ID, c.User.ID, body); err != nil {
+	if err := c.Store.AddMRComment(mr.ID, c.User.ID, body, fmtName); err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	c.Store.RecordEvent(repo.ID, c.User.ID, "mr.commented", fmt.Sprintf(`{"number":%d}`, mr.Number))

internal/control/release.go +39 −18

 func init() {
 	register(Command{Path: []string{"release", "create"},
-		Summary:    "create a release on a tag: release create <owner/name> <tag> [--title <t>] [--notes <n> | --file -]",
+		Summary:    "create a release on a tag: release create <owner/name> <tag> [--title <t>] [--notes <n> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runReleaseCreate})
 	register(Command{Path: []string{"release", "edit"},
-		Summary:    "update a release's title and notes: release edit <owner/name> <tag> [--title <t>] [--notes <n> | --file -]",
+		Summary:    "update a release's title and notes: release edit <owner/name> <tag> [--title <t>] [--notes <n> | --file -] [--format md|org]",
 		ReadsStdin: true, Run: runReleaseEdit})
 	register(Command{Path: []string{"release", "list"},
 		Summary: "list releases: release list <owner/name>", ReadOnly: true, Run: runReleaseList})
 }
 func runReleaseCreate(c *Ctx, args []string) int {
-	var path, tag, title, notes, file string
+	const usage = "usage: release create <owner/name> <tag> [--title <t>] [--notes <n> | --file -] [--format md|org]"
+	var path, tag, title, notes, file, format string
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--title", "--notes", "--file":
+		case "--title", "--notes", "--file", "--format":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "%s requires a value", args[i])
 			}
 				notes = args[i+1]
 			case "--file":
 				file = args[i+1]
+			case "--format":
+				format = args[i+1]
 			}
 			i++
 		default:
 			} else if tag == "" {
 				tag = args[i]
 			} else {
-				return c.fail(protocol.ExitUsage, "usage: release create <owner/name> <tag> [--title <t>] [--notes <n> | --file -]")
+				return c.fail(protocol.ExitUsage, usage)
 			}
 		}
 	}
 	if path == "" || tag == "" {
-		return c.fail(protocol.ExitUsage, "usage: release create <owner/name> <tag> [--title <t>] [--notes <n> | --file -]")
+		return c.fail(protocol.ExitUsage, usage)
+	}
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if fmtName == "" {
+		fmtName = "md"
 	}
 	repo, code := resolveRepo(c, path, policy.CanWrite)
 	if code >= 0 {
 	if title == "" {
 		title = tag
 	}
-	if _, err := c.Store.CreateRelease(repo.ID, tag, title, body, c.User.ID); err != nil {
+	if _, err := c.Store.CreateRelease(repo.ID, tag, title, body, c.User.ID, fmtName); err != nil {
 		return c.fail(protocol.ExitUsage, "%v", err)
 	}
 	c.Store.RecordEvent(repo.ID, c.User.ID, "release.created", fmt.Sprintf(`{"tag":%q}`, tag))
 }
 type releaseOut struct {
-	Tag       string     `json:"tag"`
+	Tag         string     `json:"tag"`
-	Title     string     `json:"title"`
+	Title       string     `json:"title"`
-	Notes     string     `json:"notes,omitempty"`
+	Notes       string     `json:"notes,omitempty"`
-	Author    string     `json:"author,omitempty"`
+	NotesFormat string     `json:"notes_format,omitempty"`
-	CreatedAt string     `json:"created_at"`
+	Author      string     `json:"author,omitempty"`
-	Assets    []assetOut `json:"assets,omitempty"`
+	CreatedAt   string     `json:"created_at"`
+	Assets      []assetOut `json:"assets,omitempty"`
 }
 func releaseToOut(r store.Release, withNotes bool) releaseOut {
 	o := releaseOut{Tag: r.Tag, Title: r.Title, Author: r.Author, CreatedAt: r.CreatedAt}
 	if withNotes {
 		o.Notes = r.Notes
+		o.NotesFormat = r.NotesFormat
 	}
 	for _, a := range r.Assets {
 		o.Assets = append(o.Assets, assetOut{a.Name, a.Size, a.SHA256})
 }
 func runReleaseEdit(c *Ctx, args []string) int {
-	const usage = "usage: release edit <owner/name> <tag> [--title <t>] [--notes <n> | --file -]"
+	const usage = "usage: release edit <owner/name> <tag> [--title <t>] [--notes <n> | --file -] [--format md|org]"
-	var path, tag, title, notes, file string
+	var path, tag, title, notes, file, format string
 	var setTitle, setNotes bool
 	for i := 0; i < len(args); i++ {
 		switch args[i] {
-		case "--title", "--notes", "--file":
+		case "--title", "--notes", "--file", "--format":
 			if i+1 >= len(args) {
 				return c.fail(protocol.ExitUsage, "%s requires a value", args[i])
 			}
 				notes, setNotes = args[i+1], true
 			case "--file":
 				file, setNotes = args[i+1], true
+			case "--format":
+				format = args[i+1]
 			}
 			i++
 		default:
 			}
 		}
 	}
-	if path == "" || tag == "" || (!setTitle && !setNotes) {
+	fmtName, err := markupFormat(format)
+	if err != nil {
+		return c.fail(protocol.ExitUsage, "%v", err)
+	}
+	if path == "" || tag == "" || (!setTitle && !setNotes && fmtName == "") {
 		return c.fail(protocol.ExitUsage, usage)
 	}
 	repo, code := resolveRepo(c, path, policy.CanWrite)
 			return c.fail(protocol.ExitUsage, "%v", err)
 		}
 	}
-	if err := c.Store.UpdateRelease(repo.ID, tag, title, body); err != nil {
+	if fmtName == "" {
+		fmtName = rel.NotesFormat
+	}
+	if err := c.Store.UpdateRelease(repo.ID, tag, title, body, fmtName); err != nil {
 		return c.fail(protocol.ExitFailure, "%v", err)
 	}
 	return c.emit(map[string]string{"tag": tag, "title": title}, func(w io.Writer) {

internal/httpd/accounts.go +5 −5

	@@ -295,7 +295,7 @@ func (s Server) issueCreateSubmit(w http.ResponseWriter, r http.Request, u sto
295	http.Error(w, "title required", http.StatusBadRequest)	295	http.Error(w, "title required", http.StatusBadRequest)
296	return	296	return
297	}	297	}
298	n, err := s.st.CreateIssue(repo.ID, u.ID, title, r.FormValue("body"))	298	n, err := s.st.CreateIssue(repo.ID, u.ID, title, r.FormValue("body"), "md")
299	if err != nil {	299	if err != nil {
300	http.Error(w, "internal error", http.StatusInternalServerError)	300	http.Error(w, "internal error", http.StatusInternalServerError)
301	return	301	return
	@@ -340,7 +340,7 @@ func (s Server) issueEditSubmit(w http.ResponseWriter, r http.Request, u store
340	return	340	return
341	}	341	}
342	body := r.FormValue("body")	342	body := r.FormValue("body")
343	if err := s.st.UpdateIssueText(iss.ID, &title, &body); err != nil {	343	if err := s.st.UpdateIssueText(iss.ID, &title, &body, nil); err != nil {
344	http.Error(w, "internal error", http.StatusInternalServerError)	344	http.Error(w, "internal error", http.StatusInternalServerError)
345	return	345	return
346	}	346	}
	@@ -381,7 +381,7 @@ func (s Server) mrEditSubmit(w http.ResponseWriter, r http.Request, u store.Us
381	return	381	return
382	}	382	}
383	body := r.FormValue("body")	383	body := r.FormValue("body")
384	if err := s.st.UpdateMRText(m.ID, &title, &body); err != nil {	384	if err := s.st.UpdateMRText(m.ID, &title, &body, nil); err != nil {
385	http.Error(w, "internal error", http.StatusInternalServerError)	385	http.Error(w, "internal error", http.StatusInternalServerError)
386	return	386	return
387	}	387	}
	@@ -404,7 +404,7 @@ func (s Server) issueCommentSubmit(w http.ResponseWriter, r http.Request, u st
404	http.Error(w, "empty comment", http.StatusBadRequest)	404	http.Error(w, "empty comment", http.StatusBadRequest)
405	return	405	return
406	}	406	}
407	if err := s.st.AddIssueComment(iss.ID, u.ID, body); err != nil {	407	if err := s.st.AddIssueComment(iss.ID, u.ID, body, "md"); err != nil {
408	http.Error(w, "internal error", http.StatusInternalServerError)	408	http.Error(w, "internal error", http.StatusInternalServerError)
409	return	409	return
410	}	410	}
	@@ -428,7 +428,7 @@ func (s Server) mrCommentSubmit(w http.ResponseWriter, r http.Request, u store
428	http.Error(w, "empty comment", http.StatusBadRequest)	428	http.Error(w, "empty comment", http.StatusBadRequest)
429	return	429	return
430	}	430	}
431	if err := s.st.AddMRComment(m.ID, u.ID, body); err != nil {	431	if err := s.st.AddMRComment(m.ID, u.ID, body, "md"); err != nil {
432	http.Error(w, "internal error", http.StatusInternalServerError)	432	http.Error(w, "internal error", http.StatusInternalServerError)
433	return	433	return
434	}	434	}

internal/httpd/orgrender_test.go +53

	@@ -112,3 +112,56 @@ func TestOrgRenderingIsUnaffectedByTheIncludeGuard(t *testing.T) {
112	}	112	}
113	}	113	}
114	}	114	}
		115
		116	// Bodies — issues, MRs, comments, release notes — render in the format they
		117	// were written in. The format travels with the text, so anything stored before
		118	// formats existed still renders as markdown.
		119
		120	func TestUGCHTMLRendersOrgWhenAsked(t *testing.T) {
		121	out := string(ugcHTML("* Heading\n\nSome /emphasis/ and =code=.", "org"))
		122
		123	if !strings.Contains(out, "<em>emphasis</em>") \|\| !strings.Contains(out, "<code>code</code>") {
		124	t.Errorf("org body did not render as org:\n%s", out)
		125	}
		126	if strings.Contains(out, "* Heading") {
		127	t.Errorf("org heading left as literal text:\n%s", out)
		128	}
		129	}
		130
		131	func TestUGCHTMLDefaultsToMarkdown(t *testing.T) {
		132	// "" is what every row written before the format column existed carries.
		133	for _, format := range []string{"", "md"} {
		134	out := string(ugcHTML("A bold claim.", format))
		135	if !strings.Contains(out, "<strong>bold</strong>") {
		136	t.Errorf("format %q did not render as markdown:\n%s", format, out)
		137	}
		138	}
		139	}
		140
		141	// An org body is not a document, so it should not grow a table of contents the
		142	// way a README does.
		143	func TestUGCHTMLOmitsTheTableOfContents(t *testing.T) {
		144	body := "* First\n\ntext\n\n* Second\n\nmore\n"
		145
		146	// The heading anchors themselves are section ids; a link to one is the
		147	// table of contents, which is what a body must not grow.
		148	if out := string(ugcHTML(body, "org")); strings.Contains(out, `href="#headline-1"`) {
		149	t.Errorf("body sprouted a table of contents:\n%s", out)
		150	}
		151	// A README still gets one.
		152	if out := string(renderReadme("README.org", []byte(body))); !strings.Contains(out, `href="#headline-1"`) {
		153	t.Errorf("README lost its table of contents:\n%s", out)
		154	}
		155	}
		156
		157	// Bodies are the lowest-trust org on the instance: repo content needs push
		158	// access, but anyone who can comment can write one. The include guard must
		159	// cover them.
		160	func TestUGCHTMLOrgCannotReadServerFiles(t *testing.T) {
		161	path := secretFile(t)
		162	body := "#+INCLUDE: \"" + path + "\" src text\n"
		163
		164	if out := string(ugcHTML(body, "org")); strings.Contains(out, orgSecret) {
		165	t.Fatalf("an org body read a server file:\n%s", out)
		166	}
		167	}

internal/httpd/web.go +62 −26

 	}
 	var views []relView
 	for _, rel := range rels {
-		views = append(views, relView{rel, md(rel.Notes)})
+		views = append(views, relView{rel, md(rel.Notes, rel.NotesFormat)})
 	}
 	// Tags without a release yet are what a create form can offer.
 	released := map[string]bool{}
 	return ""
 }
-// ugcFor returns a renderer for user-authored markdown on one repo's pages:
+// ugcRenderer renders one user-authored body in the format it was written in.
-// mdHTML plus cross-reference and mention autolinking for this viewer.
+// The format travels with the body: it is recorded when the text is written, so
-func (s *Server) ugcFor(r *http.Request, repo store.Repo) func(string) template.HTML {
+// changing a preference later cannot re-interpret prose that already exists.
+type ugcRenderer func(raw, format string) template.HTML
+// ugcHTML renders a user-authored body. Anything other than "org" is markdown,
+// so a body stored before formats existed — and any row whose column defaulted —
+// renders exactly as it did before.
+//
+// Org goes through renderReadme, the same path READMEs, wiki pages and profile
+// about text take, so it inherits that function's include guard and sanitising
+// rather than growing a second org renderer to keep in step.
+func ugcHTML(raw, format string) template.HTML {
+	if format == "org" {
+		return renderOrg("body.org", []byte(raw), false, func() template.HTML {
+			return template.HTML("<pre>" + template.HTMLEscapeString(raw) + "</pre>")
+		})
+	}
+	return mdHTML(raw)
+}
+// ugcFor returns a renderer for user-authored bodies on one repo's pages:
+// ugcHTML plus cross-reference and mention autolinking for this viewer.
+func (s *Server) ugcFor(r *http.Request, repo store.Repo) ugcRenderer {
 	viewer := store.User{}
 	if s.cfg.Web.Mode == "accounts" {
 		viewer = s.viewer(r)
 	}
 	res := webResolver{s, viewer}
-	return func(raw string) template.HTML {
+	return func(raw, format string) template.HTML {
-		h := mdHTML(raw)
+		h := ugcHTML(raw, format)
 		if h == "" {
 			return h
 		}
 	BodyHTML  template.HTML
 }
-func renderComments(cs []store.IssueComment, md func(string) template.HTML) []renderedComment {
+func renderComments(cs []store.IssueComment, ugc ugcRenderer) []renderedComment {
 	var out []renderedComment
 	for _, c := range cs {
-		out = append(out, renderedComment{c.Author, c.CreatedAt, c.Kind, md(c.Body)})
+		out = append(out, renderedComment{c.Author, c.CreatedAt, c.Kind, ugc(c.Body, c.BodyFormat)})
 	}
 	return out
 }
 var errOrgIncludeDisabled = errors.New("org: #+INCLUDE and #+SETUPFILE are disabled")
+// renderOrg renders org to sanitized HTML. `contents` asks go-org for its table
+// of contents: a README or wiki page is a document and carries one, an issue
+// comment is a remark and should not sprout one above two headings. `fallback`
+// supplies the plaintext rendering used when the writer fails.
+func renderOrg(name string, raw []byte, contents bool, fallback func() template.HTML) template.HTML {
+	c := orgConfig()
+	if !contents {
+		// DefaultSettings is a fresh map per org.New(), so this is local.
+		c.DefaultSettings["OPTIONS"] = strings.ReplaceAll(c.DefaultSettings["OPTIONS"], "toc:t", "toc:nil")
+	}
+	doc := c.Parse(bytes.NewReader(raw), name)
+	writer := org.NewHTMLWriter()
+	writer.HighlightCodeBlock = func(source, lang string, inline bool, params map[string]string) string {
+		if inline {
+			return "<code>" + template.HTMLEscapeString(source) + "</code>"
+		}
+		return fenceHighlight(source, lang)
+	}
+	out, err := doc.Write(writer)
+	if err != nil {
+		return fallback()
+	}
+	return template.HTML(ugcPolicy.Sanitize(out))
+}
 func renderReadme(name string, raw []byte) template.HTML {
 	plain := func() template.HTML {
 		return template.HTML("<pre>" + template.HTMLEscapeString(string(raw)) + "</pre>")
 		}
 		return template.HTML(buf.String())
 	case ".org":
-		doc := orgConfig().Parse(bytes.NewReader(raw), name)
+		return renderOrg(name, raw, true, plain)
-		writer := org.NewHTMLWriter()
-		writer.HighlightCodeBlock = func(source, lang string, inline bool, params map[string]string) string {
-			if inline {
-				return "<code>" + template.HTMLEscapeString(source) + "</code>"
-			}
-			return fenceHighlight(source, lang)
-		}
-		out, err := doc.Write(writer)
-		if err != nil {
-			return plain()
-		}
-		return template.HTML(ugcPolicy.Sanitize(out))
 	case ".html", ".htm":
 		return template.HTML(ugcPolicy.Sanitize(string(raw)))
 	default:
 // attachThreads injects review threads under their anchored diff lines;
 // threads whose anchor no longer appears (stale after force-push, or on a
 // context line outside the current diff) are returned separately.
-func attachThreads(files []diffFile, comments []store.DiffComment, headSHA string, md func(string) template.HTML) ([]diffFile, []diffThread) {
+func attachThreads(files []diffFile, comments []store.DiffComment, headSHA string, md ugcRenderer) ([]diffFile, []diffThread) {
 	type anchor struct {
 		path string
 		side string
 		line int64
 	}
+	// Diff-line comments have no stored format yet, so they stay markdown.
+	// They are the one user-authored body left without the choice; see #51.
 	threads := map[int64]*diffThread{}
 	anchors := map[int64]anchor{}
 	var order []int64
 	for _, cm := range comments {
 		if cm.ReplyTo == 0 {
 			threads[cm.ID] = &diffThread{ID: cm.ID, Resolved: cm.ResolvedBy, Stale: cm.HeadSHA != headSHA,
-				Comments: []renderedComment{{Author: cm.Author, CreatedAt: cm.CreatedAt, BodyHTML: md(cm.Body)}}}
+				Comments: []renderedComment{{Author: cm.Author, CreatedAt: cm.CreatedAt, BodyHTML: md(cm.Body, "md")}}}
 			anchors[cm.ID] = anchor{cm.Path, cm.Side, cm.Line}
 			order = append(order, cm.ID)
 		} else if th, ok := threads[cm.ReplyTo]; ok {
-			th.Comments = append(th.Comments, renderedComment{Author: cm.Author, CreatedAt: cm.CreatedAt, BodyHTML: md(cm.Body)})
+			th.Comments = append(th.Comments, renderedComment{Author: cm.Author, CreatedAt: cm.CreatedAt, BodyHTML: md(cm.Body, "md")})
 		}
 	}
 	placed := map[int64]bool{}
 		Milestones  []store.Milestone
 		Notice      string
 		LabelColors map[string]template.CSS
-	}{p, iss, md(iss.Body), renderComments(comments, md),
+	}{p, iss, md(iss.Body, iss.BodyFormat), renderComments(comments, md),
 		s.canEditItem(r, p.Repo, iss.Author), s.canWriteRepo(r, p.Repo),
 		milestones, r.URL.Query().Get("e"), s.labelColors(p.Repo.ID)})
 }
 		Unresolved      int
 		Notice          string
 		DetachedThreads []diffThread
-	}{p, m, view, md(m.Body), checks, store.CombinedStatus(checks), renderComments(comments, md),
+	}{p, m, view, md(m.Body, m.BodyFormat), checks, store.CombinedStatus(checks), renderComments(comments, md),
 		reviews, files, stat, commits, s.canEditItem(r, p.Repo, m.Author),
 		s.canWriteRepo(r, p.Repo), unresolved, r.URL.Query().Get("e"), detachedThreads})
 }

internal/store/issues.go +36 −30

 )
 type Issue struct {
-	ID        int64
+	ID         int64
-	RepoID    int64
+	RepoID     int64
-	Number    int64
+	Number     int64
-	Author    string
+	Author     string
-	Title     string
+	Title      string
-	Body      string
+	Body       string
-	State     string // open | closed
+	BodyFormat string // md | org
-	Milestone string
+	State      string // open | closed
-	CreatedAt string
+	Milestone  string
-	UpdatedAt string
+	CreatedAt  string
-	Labels    []string
+	UpdatedAt  string
-	Assignees []string
+	Labels     []string
+	Assignees  []string
 }
 type IssueComment struct {
-	Author    string
+	Author     string
-	Body      string
+	Body       string
-	CreatedAt string
+	BodyFormat string // md | org
-	Kind      string // comment | system
+	CreatedAt  string
+	Kind       string // comment | system
 }
 // CreateIssue allocates the per-repo number from the repo counter inside the
 // same transaction as the insert — MAX(number)+1 races.
-func (s *Store) CreateIssue(repoID, authorID int64, title, body string) (int64, error) {
+func (s *Store) CreateIssue(repoID, authorID int64, title, body, format string) (int64, error) {
 	tx, err := s.DB.Begin()
 	if err != nil {
 		return 0, err
 		return 0, err
 	}
 	if _, err := tx.Exec(
-		"INSERT INTO issues (repo_id, number, author_id, title, body) VALUES (?, ?, ?, ?, ?)",
+		"INSERT INTO issues (repo_id, number, author_id, title, body, body_format) VALUES (?, ?, ?, ?, ?, ?)",
-		repoID, n, authorID, title, body); err != nil {
+		repoID, n, authorID, title, body, format); err != nil {
 		return 0, err
 	}
 	return n, tx.Commit()
 func (s *Store) IssueByNumber(repoID, number int64) (Issue, error) {
 	var i Issue
 	err := s.DB.QueryRow(`
-		SELECT i.id, i.repo_id, i.number, u.username, i.title, i.body, i.state,
+		SELECT i.id, i.repo_id, i.number, u.username, i.title, i.body, i.body_format, i.state,
 		       COALESCE(m.title, ''), i.created_at, i.updated_at
 		FROM issues i JOIN users u ON u.id = i.author_id
 		LEFT JOIN milestones m ON m.id = i.milestone_id
 		WHERE i.repo_id = ? AND i.number = ?`, repoID, number).
-		Scan(&i.ID, &i.RepoID, &i.Number, &i.Author, &i.Title, &i.Body, &i.State, &i.Milestone, &i.CreatedAt, &i.UpdatedAt)
+		Scan(&i.ID, &i.RepoID, &i.Number, &i.Author, &i.Title, &i.Body, &i.BodyFormat, &i.State, &i.Milestone, &i.CreatedAt, &i.UpdatedAt)
 	if errors.Is(err, sql.ErrNoRows) {
 		return i, ErrNotFound
 	}
 // "all". limit 0 means everything; before (an issue number) starts the
 // page strictly below it, matching the number-descending order.
 func (s *Store) ListIssues(repoID int64, state string, limit int, before int64) ([]Issue, error) {
-	q := `SELECT i.id, i.repo_id, i.number, u.username, i.title, i.body, i.state,
+	q := `SELECT i.id, i.repo_id, i.number, u.username, i.title, i.body, i.body_format, i.state,
 	             COALESCE(m.title, ''), i.created_at, i.updated_at
 	      FROM issues i JOIN users u ON u.id = i.author_id
 	      LEFT JOIN milestones m ON m.id = i.milestone_id
 	var out []Issue
 	for rows.Next() {
 		var i Issue
-		if err := rows.Scan(&i.ID, &i.RepoID, &i.Number, &i.Author, &i.Title, &i.Body, &i.State, &i.Milestone, &i.CreatedAt, &i.UpdatedAt); err != nil {
+		if err := rows.Scan(&i.ID, &i.RepoID, &i.Number, &i.Author, &i.Title, &i.Body, &i.BodyFormat, &i.State, &i.Milestone, &i.CreatedAt, &i.UpdatedAt); err != nil {
 			return nil, err
 		}
 		out = append(out, i)
 	return out, rows.Err()
 }
-// UpdateIssueText edits title and/or body; nil leaves a field unchanged.
+// UpdateIssueText edits title, body, and/or markup format; nil leaves a field
-func (s *Store) UpdateIssueText(issueID int64, title, body *string) error {
+// unchanged.
+func (s *Store) UpdateIssueText(issueID int64, title, body, format *string) error {
 	set, args := []string{}, []any{}
 	if title != nil {
 		set, args = append(set, "title = ?"), append(args, *title)
 	if body != nil {
 		set, args = append(set, "body = ?"), append(args, *body)
 	}
+	if format != nil {
+		set, args = append(set, "body_format = ?"), append(args, *format)
+	}
 	if len(set) == 0 {
 		return nil
 	}
 	return nil
 }
-func (s *Store) AddIssueComment(issueID, authorID int64, body string) error {
+func (s *Store) AddIssueComment(issueID, authorID int64, body, format string) error {
 	tx, err := s.DB.Begin()
 	if err != nil {
 		return err
 	}
 	defer tx.Rollback()
 	if _, err := tx.Exec(
-		"INSERT INTO issue_comments (issue_id, author_id, body) VALUES (?, ?, ?)",
+		"INSERT INTO issue_comments (issue_id, author_id, body, body_format) VALUES (?, ?, ?, ?)",
-		issueID, authorID, body); err != nil {
+		issueID, authorID, body, format); err != nil {
 		return err
 	}
 	if _, err := tx.Exec(
 func (s *Store) ListIssueComments(issueID int64) ([]IssueComment, error) {
 	rows, err := s.DB.Query(`
 		SELECT CASE WHEN c.kind = 'system' THEN 'system' ELSE u.username END,
-		       c.body, c.created_at, c.kind
+		       c.body, c.body_format, c.created_at, c.kind
 		FROM issue_comments c JOIN users u ON u.id = c.author_id
 		WHERE c.issue_id = ? ORDER BY c.id`, issueID)
 	if err != nil {
 	var out []IssueComment
 	for rows.Next() {
 		var c IssueComment
-		if err := rows.Scan(&c.Author, &c.Body, &c.CreatedAt, &c.Kind); err != nil {
+		if err := rows.Scan(&c.Author, &c.Body, &c.BodyFormat, &c.CreatedAt, &c.Kind); err != nil {
 			return nil, err
 		}
 		out = append(out, c)

internal/store/migrations/0027_body_format.down.sql added +5

@@ -0,0 +1,5 @@
	1	ALTER TABLE issues DROP COLUMN body_format;
	2	ALTER TABLE issue_comments DROP COLUMN body_format;
	3	ALTER TABLE merge_requests DROP COLUMN body_format;
	4	ALTER TABLE mr_comments DROP COLUMN body_format;
	5	ALTER TABLE releases DROP COLUMN notes_format;

internal/store/migrations/0027_body_format.up.sql added +5

@@ -0,0 +1,5 @@
	1	ALTER TABLE issues ADD COLUMN body_format TEXT NOT NULL DEFAULT 'md';
	2	ALTER TABLE issue_comments ADD COLUMN body_format TEXT NOT NULL DEFAULT 'md';
	3	ALTER TABLE merge_requests ADD COLUMN body_format TEXT NOT NULL DEFAULT 'md';
	4	ALTER TABLE mr_comments ADD COLUMN body_format TEXT NOT NULL DEFAULT 'md';
	5	ALTER TABLE releases ADD COLUMN notes_format TEXT NOT NULL DEFAULT 'md';

internal/store/mrs.go +18 −12

 	TargetRef    string
 	Title        string
 	Body         string
+	BodyFormat   string // md | org
 	State        string // open | merged | closed | source_gone
 	Milestone    string
 	HeadSHA      string
 	CreatedAt string
 }
-func (s *Store) CreateMR(repoID, authorID, sourceRepoID int64, sourceRef, targetRef, title, body, headSHA string) (int64, error) {
+func (s *Store) CreateMR(repoID, authorID, sourceRepoID int64, sourceRef, targetRef, title, body, headSHA, format string) (int64, error) {
 	tx, err := s.DB.Begin()
 	if err != nil {
 		return 0, err
 		return 0, err
 	}
 	if _, err := tx.Exec(`
-		INSERT INTO merge_requests (repo_id, number, author_id, source_repo_id, source_ref, target_ref, title, body, head_sha)
+		INSERT INTO merge_requests (repo_id, number, author_id, source_repo_id, source_ref, target_ref, title, body, head_sha, body_format)
-		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-		repoID, n, authorID, sourceRepoID, sourceRef, targetRef, title, body, headSHA); err != nil {
+		repoID, n, authorID, sourceRepoID, sourceRef, targetRef, title, body, headSHA, format); err != nil {
 		return 0, err
 	}
 	return n, tx.Commit()
 	SELECT m.id, m.repo_id, m.number, u.username,
 	       COALESCE(m.source_repo_id, 0),
 	       COALESCE(COALESCE(su.username, so.name) || '/' || sr.name, ''),
-	       m.source_ref, m.target_ref, m.title, m.body, m.state,
+	       m.source_ref, m.target_ref, m.title, m.body, m.body_format, m.state,
 	       COALESCE(ms.title, ''), m.head_sha,
 	       m.merged_base, m.created_at, m.updated_at
 	FROM merge_requests m
 func scanMR(row interface{ Scan(...any) error }) (MR, error) {
 	var m MR
 	err := row.Scan(&m.ID, &m.RepoID, &m.Number, &m.Author, &m.SourceRepoID, &m.SourcePath,
-		&m.SourceRef, &m.TargetRef, &m.Title, &m.Body, &m.State, &m.Milestone, &m.HeadSHA, &m.MergedBase, &m.CreatedAt, &m.UpdatedAt)
+		&m.SourceRef, &m.TargetRef, &m.Title, &m.Body, &m.BodyFormat, &m.State, &m.Milestone, &m.HeadSHA, &m.MergedBase, &m.CreatedAt, &m.UpdatedAt)
 	return m, err
 }
 	return err
 }
-func (s *Store) AddMRComment(mrID, authorID int64, body string) error {
+func (s *Store) AddMRComment(mrID, authorID int64, body, format string) error {
 	_, err := s.DB.Exec(
-		"INSERT INTO mr_comments (mr_id, author_id, body) VALUES (?, ?, ?)", mrID, authorID, body)
+		"INSERT INTO mr_comments (mr_id, author_id, body, body_format) VALUES (?, ?, ?, ?)",
+		mrID, authorID, body, format)
 	return err
 }
-// UpdateMRText edits title and/or body; nil leaves a field unchanged.
+// UpdateMRText edits title, body, and/or markup format; nil leaves a field
-func (s *Store) UpdateMRText(mrID int64, title, body *string) error {
+// unchanged.
+func (s *Store) UpdateMRText(mrID int64, title, body, format *string) error {
 	set, args := []string{}, []any{}
 	if title != nil {
 		set, args = append(set, "title = ?"), append(args, *title)
 	if body != nil {
 		set, args = append(set, "body = ?"), append(args, *body)
 	}
+	if format != nil {
+		set, args = append(set, "body_format = ?"), append(args, *format)
+	}
 	if len(set) == 0 {
 		return nil
 	}
 func (s *Store) ListMRComments(mrID int64) ([]IssueComment, error) {
 	rows, err := s.DB.Query(`
 		SELECT CASE WHEN c.kind = 'system' THEN 'system' ELSE u.username END,
-		       c.body, c.created_at, c.kind
+		       c.body, c.body_format, c.created_at, c.kind
 		FROM mr_comments c JOIN users u ON u.id = c.author_id
 		WHERE c.mr_id = ? ORDER BY c.id`, mrID)
 	if err != nil {
 	var out []IssueComment
 	for rows.Next() {
 		var c IssueComment
-		if err := rows.Scan(&c.Author, &c.Body, &c.CreatedAt, &c.Kind); err != nil {
+		if err := rows.Scan(&c.Author, &c.Body, &c.BodyFormat, &c.CreatedAt, &c.Kind); err != nil {
 			return nil, err
 		}
 		out = append(out, c)

internal/store/releases.go +19 −18

 )
 type Release struct {
-	ID        int64
+	ID          int64
-	RepoID    int64
+	RepoID      int64
-	Tag       string
+	Tag         string
-	Title     string
+	Title       string
-	Notes     string
+	Notes       string
-	Author    string
+	NotesFormat string // md | org
-	CreatedAt string
+	Author      string
-	Assets    []ReleaseAsset
+	CreatedAt   string
+	Assets      []ReleaseAsset
 }
 type ReleaseAsset struct {
 	UploadedAt string
 }
-func (s *Store) CreateRelease(repoID int64, tag, title, notes string, authorID int64) (int64, error) {
+func (s *Store) CreateRelease(repoID int64, tag, title, notes string, authorID int64, format string) (int64, error) {
 	res, err := s.DB.Exec(
-		"INSERT INTO releases (repo_id, tag, title, notes, author_id) VALUES (?, ?, ?, ?, ?)",
+		"INSERT INTO releases (repo_id, tag, title, notes, author_id, notes_format) VALUES (?, ?, ?, ?, ?, ?)",
-		repoID, tag, title, notes, authorID)
+		repoID, tag, title, notes, authorID, format)
 	if err != nil {
 		if isUniqueErr(err) {
 			return 0, fmt.Errorf("a release for tag %q already exists", tag)
 }
 const releaseSelect = `
-	SELECT r.id, r.repo_id, r.tag, r.title, r.notes, COALESCE(u.username, ''), r.created_at
+	SELECT r.id, r.repo_id, r.tag, r.title, r.notes, r.notes_format, COALESCE(u.username, ''), r.created_at
 	FROM releases r LEFT JOIN users u ON u.id = r.author_id`
 func (s *Store) releaseAssets(rel *Release) error {
 	return rows.Err()
 }
-// UpdateRelease replaces a release's title and notes.
+// UpdateRelease replaces a release's title, notes, and markup format.
-func (s *Store) UpdateRelease(repoID int64, tag, title, notes string) error {
+func (s *Store) UpdateRelease(repoID int64, tag, title, notes, format string) error {
 	res, err := s.DB.Exec(
-		"UPDATE releases SET title = ?, notes = ? WHERE repo_id = ? AND tag = ?",
+		"UPDATE releases SET title = ?, notes = ?, notes_format = ? WHERE repo_id = ? AND tag = ?",
-		title, notes, repoID, tag)
+		title, notes, format, repoID, tag)
 	if err != nil {
 		return err
 	}
 func (s *Store) ReleaseByTag(repoID int64, tag string) (Release, error) {
 	var r Release
 	err := s.DB.QueryRow(releaseSelect+" WHERE r.repo_id = ? AND r.tag = ?", repoID, tag).
-		Scan(&r.ID, &r.RepoID, &r.Tag, &r.Title, &r.Notes, &r.Author, &r.CreatedAt)
+		Scan(&r.ID, &r.RepoID, &r.Tag, &r.Title, &r.Notes, &r.NotesFormat, &r.Author, &r.CreatedAt)
 	if errors.Is(err, sql.ErrNoRows) {
 		return r, ErrNotFound
 	}
 	var out []Release
 	for rows.Next() {
 		var r Release
-		if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.Title, &r.Notes, &r.Author, &r.CreatedAt); err != nil {
+		if err := rows.Scan(&r.ID, &r.RepoID, &r.Tag, &r.Title, &r.Notes, &r.NotesFormat, &r.Author, &r.CreatedAt); err != nil {
 			return nil, err
 		}
 		out = append(out, r)