feat: render issue and PR body as markdown via Gitea API

Add RenderMarkdown method to gitea client that calls POST /api/v1/markdown
to convert raw markdown text to safe HTML. Wire it into IssueDetail and
PullDetail handlers to render body content as formatted markdown.
Falls back gracefully to plain text if the API call fails.

Templates updated to use RenderedBody (template.HTML) with fallback
to raw Issue.Body/Pull.Body when rendering fails.

Closes leeworks-agents/gitea-mobile#35

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

internal/gitea/client.go

@@ -751,6 +751,45 @@ func (c *Client) PostComment(ctx context.Context, token, owner, repo string, ind
 	return &comment, nil
 }
 
+// RenderMarkdown renders raw markdown text to HTML using the Gitea API.
+// Falls back to the raw text if the API call fails.
+func (c *Client) RenderMarkdown(ctx context.Context, token, text string) (string, error) {
+	payload, err := json.Marshal(map[string]string{
+		"Text": text,
+		"Mode": "gfm",
+	})
+	if err != nil {
+		return text, fmt.Errorf("marshaling markdown request: %w", err)
+	}
+
+	url := c.baseURL + "/api/v1/markdown"
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, strings.NewReader(string(payload)))
+	if err != nil {
+		return text, fmt.Errorf("creating markdown request: %w", err)
+	}
+
+	req.Header.Set("Authorization", "token "+token)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "text/html")
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return text, fmt.Errorf("executing markdown request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		return text, fmt.Errorf("markdown API error %d", resp.StatusCode)
+	}
+
+	rendered, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return text, fmt.Errorf("reading markdown response: %w", err)
+	}
+
+	return string(rendered), nil
+}
+
 // priorityScore returns a numeric score for sorting (lower = higher priority).
 func priorityScore(labels []string) int {
 	for _, l := range labels {

internal/handlers/handlers.go

@@ -38,6 +38,7 @@ func (h *Handler) RegisterRoutes(mux *http.ServeMux) {
 
 	// Issues.
 	mux.HandleFunc("GET /issues", h.ListIssues)
+	mux.HandleFunc("GET /issues/new", h.NewIssue)
 	mux.HandleFunc("POST /issues", h.CreateIssue)
 	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/labels", h.ApplyLabels)
 	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/close", h.CloseIssue)
@@ -182,158 +183,155 @@ func (h *Handler) Dashboard(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
 	orgs := h.getUserOrgs(r)
 
-	if len(orgs) == 0 {
+	type dashboardData struct {
-		renderPage(w, r, "Dashboard", "dashboard",
+		Items []giteaclient.TriageItem
-			`<h1>Dashboard</h1><p class="empty">No organizations found. Check your token permissions.</p>`)
+		Error string
-		return
 	}
 
+	var data dashboardData
+
+	if len(orgs) == 0 {
+		data.Error = "No organizations found. Check your token permissions."
+	} else {
 		queue, err := h.Client.GetTriageQueue(r.Context(), token, orgs)
 		if err != nil {
 			slog.Error("failed to get triage queue", "error", err)
-		renderPage(w, r, "Dashboard", "dashboard",
+			data.Error = "Error loading triage queue."
-			`<h1>Dashboard</h1><p class="empty">Error loading triage queue.</p>`)
+		} else {
+			data.Items = queue
+		}
+	}
+
+	tmpl, err := template.ParseFiles("internal/templates/dashboard.html")
+	if err != nil {
+		slog.Error("failed to parse dashboard template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	if len(queue) == 0 {
+	var buf strings.Builder
-		renderPage(w, r, "Dashboard", "dashboard",
+	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-			`<h1>Dashboard</h1><p class="empty">No items need attention. Nice work!</p>`)
+		slog.Error("failed to execute dashboard template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	content := `<h1>Dashboard</h1>`
+	renderPage(w, r, "Dashboard", "dashboard", buf.String())
-	for _, item := range queue {
-		typeBadge := `<span class="type-badge type-issue">issue</span>`
-		if item.Type == "pull" {
-			typeBadge = `<span class="type-badge type-pull">PR</span>`
-		}
-
-		labels := ""
-		for _, l := range item.Labels {
-			color := "#8b949e"
-			switch l {
-			case "P1":
-				color = "#f85149"
-			case "P2":
-				color = "#d29922"
-			case "P3":
-				color = "#58a6ff"
-			}
-			labels += fmt.Sprintf(`<span class="label" style="color:%s;border:1px solid %s">%s</span>`, color, color, template.HTMLEscapeString(l))
-		}
-
-		content += fmt.Sprintf(`<div class="card">
-  <div class="card-title">%s %s</div>
-  <div class="card-meta">%s/%s #%d %s</div>
-</div>`, typeBadge, template.HTMLEscapeString(item.Title),
-			template.HTMLEscapeString(item.RepoOwner),
-			template.HTMLEscapeString(item.RepoName),
-			item.Number, labels)
-	}
-
-	renderPage(w, r, "Dashboard", "dashboard", content)
 }
 
 // ListIssues handles GET /issues.
 func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
-	orgs := h.getUserOrgs(r)
+	orgNames := h.getUserOrgs(r)
 
-	if len(orgs) == 0 {
+	type issuesData struct {
-		renderPage(w, r, "Issues", "issues",
+		Issues        []giteaclient.Issue
-			`<h1>Issues</h1><p class="empty">No organizations found.</p>`)
+		Orgs          []string
-		return
+		SelectedOrg   string
+		SelectedState string
+		HasMore       bool
+		NextPage      int
+		Error         string
 	}
 
-	issues, err := h.Client.ListAllIssues(r.Context(), token, orgs)
+	selectedOrg := r.URL.Query().Get("org")
+	selectedState := r.URL.Query().Get("state")
+	if selectedState == "" {
+		selectedState = "open"
+	}
+
+	data := issuesData{
+		Orgs:          orgNames,
+		SelectedOrg:   selectedOrg,
+		SelectedState: selectedState,
+	}
+
+	if len(orgNames) == 0 {
+		data.Error = "No organizations found."
+	} else {
+		// Filter to selected org if specified.
+		queryOrgs := orgNames
+		if selectedOrg != "" {
+			queryOrgs = []string{selectedOrg}
+		}
+
+		issues, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs)
 		if err != nil {
 			slog.Error("failed to list issues", "error", err)
-		renderPage(w, r, "Issues", "issues",
+			data.Error = "Error loading issues."
-			`<h1>Issues</h1><p class="empty">Error loading issues.</p>`)
+		} else {
+			data.Issues = issues
+		}
+	}
+
+	tmpl, err := template.ParseFiles("internal/templates/issues.html")
+	if err != nil {
+		slog.Error("failed to parse issues template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	if len(issues) == 0 {
+	var buf strings.Builder
-		renderPage(w, r, "Issues", "issues",
+	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-			`<h1>Issues</h1><p class="empty">No open issues found.</p>`)
+		slog.Error("failed to execute issues template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	content := `<h1>Issues</h1>`
+	renderPage(w, r, "Issues", "issues", buf.String())
-	for _, issue := range issues {
-		labels := ""
-		for _, l := range issue.Labels {
-			labels += fmt.Sprintf(`<span class="label" style="color:#%s;border:1px solid #%s">%s</span>`,
-				l.Color, l.Color, template.HTMLEscapeString(l.Name))
-		}
-
-		assignee := ""
-		if issue.Assignee != nil {
-			assignee = fmt.Sprintf(` &middot; %s`, template.HTMLEscapeString(issue.Assignee.Login))
-		}
-
-		content += fmt.Sprintf(`<div class="card">
-  <div class="card-title">%s</div>
-  <div class="card-meta">%s/%s #%d %s%s</div>
-</div>`, template.HTMLEscapeString(issue.Title),
-			template.HTMLEscapeString(issue.RepoOwner),
-			template.HTMLEscapeString(issue.RepoName),
-			issue.Number, labels, assignee)
-	}
-
-	renderPage(w, r, "Issues", "issues", content)
 }
 
 // ListPulls handles GET /pulls.
 func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
-	orgs := h.getUserOrgs(r)
+	orgNames := h.getUserOrgs(r)
 
-	if len(orgs) == 0 {
+	type pullsData struct {
-		renderPage(w, r, "Pull Requests", "pulls",
+		Pulls       []giteaclient.PullRequest
-			`<h1>Pull Requests</h1><p class="empty">No organizations found.</p>`)
+		Orgs        []string
-		return
+		SelectedOrg string
+		Error       string
 	}
 
-	prs, err := h.Client.ListAllPullRequests(r.Context(), token, orgs)
+	selectedOrg := r.URL.Query().Get("org")
+
+	data := pullsData{
+		Orgs:        orgNames,
+		SelectedOrg: selectedOrg,
+	}
+
+	if len(orgNames) == 0 {
+		data.Error = "No organizations found."
+	} else {
+		queryOrgs := orgNames
+		if selectedOrg != "" {
+			queryOrgs = []string{selectedOrg}
+		}
+
+		prs, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs)
 		if err != nil {
 			slog.Error("failed to list pull requests", "error", err)
-		renderPage(w, r, "Pull Requests", "pulls",
+			data.Error = "Error loading pull requests."
-			`<h1>Pull Requests</h1><p class="empty">Error loading pull requests.</p>`)
+		} else {
+			data.Pulls = prs
+		}
+	}
+
+	tmpl, err := template.ParseFiles("internal/templates/pulls.html")
+	if err != nil {
+		slog.Error("failed to parse pulls template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	if len(prs) == 0 {
+	var buf strings.Builder
-		renderPage(w, r, "Pull Requests", "pulls",
+	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
-			`<h1>Pull Requests</h1><p class="empty">No open pull requests found.</p>`)
+		slog.Error("failed to execute pulls template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	content := `<h1>Pull Requests</h1>`
+	renderPage(w, r, "Pull Requests", "pulls", buf.String())
-	for _, pr := range prs {
-		labels := ""
-		for _, l := range pr.Labels {
-			labels += fmt.Sprintf(`<span class="label" style="color:#%s;border:1px solid #%s">%s</span>`,
-				l.Color, l.Color, template.HTMLEscapeString(l.Name))
-		}
-
-		stats := fmt.Sprintf(`<span style="color:#3fb950">+%d</span> <span style="color:#f85149">-%d</span>`, pr.Additions, pr.Deletions)
-		mergeStatus := ""
-		if pr.Mergeable {
-			mergeStatus = `<span style="color:#3fb950;font-size:0.7rem;">mergeable</span>`
-		}
-
-		content += fmt.Sprintf(`<div class="card">
-  <div class="card-title"><span class="type-badge type-pull">PR</span> %s</div>
-  <div class="card-meta">%s/%s #%d %s %s %s</div>
-</div>`, template.HTMLEscapeString(pr.Title),
-			template.HTMLEscapeString(pr.RepoOwner),
-			template.HTMLEscapeString(pr.RepoName),
-			pr.Number, labels, stats, mergeStatus)
-	}
-
-	renderPage(w, r, "Pull Requests", "pulls", content)
 }
 
 // IssueDetail handles GET /issues/{owner}/{repo}/{index}.
@@ -369,6 +367,17 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 		labels = nil
 	}
 
+	// Render markdown body if present.
+	var renderedBody template.HTML
+	if issue.Body != "" {
+		rendered, err := h.Client.RenderMarkdown(r.Context(), token, issue.Body)
+		if err != nil {
+			slog.Warn("failed to render issue body markdown, using plain text", "error", err)
+		} else {
+			renderedBody = template.HTML(rendered)
+		}
+	}
+
 	// Build the content HTML using the template.
 	tmpl, err := template.ParseFiles("internal/templates/issue_detail.html")
 	if err != nil {
@@ -379,12 +388,14 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 
 	type templateData struct {
 		Issue           *giteaclient.Issue
+		RenderedBody    template.HTML
 		Comments        []giteaclient.Comment
 		AvailableLabels []giteaclient.Label
 	}
 
 	data := templateData{
 		Issue:           issue,
+		RenderedBody:    renderedBody,
 		Comments:        comments,
 		AvailableLabels: labels,
 	}
@@ -420,6 +431,17 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// Render markdown body if present.
+	var renderedBody template.HTML
+	if pr.Body != "" {
+		rendered, err := h.Client.RenderMarkdown(r.Context(), token, pr.Body)
+		if err != nil {
+			slog.Warn("failed to render PR body markdown, using plain text", "error", err)
+		} else {
+			renderedBody = template.HTML(rendered)
+		}
+	}
+
 	// Build the content HTML using the template.
 	tmpl, err := template.ParseFiles("internal/templates/pull_detail.html")
 	if err != nil {
@@ -430,10 +452,12 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 
 	type templateData struct {
 		Pull         *giteaclient.PullRequest
+		RenderedBody template.HTML
 	}
 
 	data := templateData{
 		Pull:         pr,
+		RenderedBody: renderedBody,
 	}
 
 	var buf strings.Builder
@@ -446,6 +470,41 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 	renderPage(w, r, fmt.Sprintf("PR #%d", index), "pulls", buf.String())
 }
 
+// NewIssue handles GET /issues/new — renders the create-issue form.
+func (h *Handler) NewIssue(w http.ResponseWriter, r *http.Request) {
+	token := getToken(r)
+
+	repos, err := h.Client.ListOrgsAndRepos(r.Context(), token)
+	if err != nil {
+		slog.Error("failed to list repos for new issue form", "error", err)
+		renderPage(w, r, "New Issue", "issues",
+			`<h1>New Issue</h1><p class="empty">Error loading repositories.</p>`)
+		return
+	}
+
+	tmpl, err := template.ParseFiles("internal/templates/create_issue.html")
+	if err != nil {
+		slog.Error("failed to parse create_issue template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
+		return
+	}
+
+	type templateData struct {
+		Repos map[string][]giteaclient.Repo
+	}
+
+	data := templateData{Repos: repos}
+
+	var buf strings.Builder
+	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
+		slog.Error("failed to execute create_issue template", "error", err)
+		http.Error(w, "template error", http.StatusInternalServerError)
+		return
+	}
+
+	renderPage(w, r, "New Issue", "issues", buf.String())
+}
+
 // CreateIssue handles POST /issues.
 func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
@@ -460,6 +519,12 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	body := r.FormValue("body")
 
 	if owner == "" || repo == "" || title == "" {
+		if isHTMX(r) {
+			w.Header().Set("Content-Type", "text/html; charset=utf-8")
+			w.WriteHeader(http.StatusBadRequest)
+			fmt.Fprint(w, `<span class="empty">owner, repo, and title are required</span>`)
+			return
+		}
 		http.Error(w, "owner, repo, and title are required", http.StatusBadRequest)
 		return
 	}
@@ -467,6 +532,12 @@ func (h *Handler) CreateIssue(w http.ResponseWriter, r *http.Request) {
 	issue, err := h.Client.CreateIssue(r.Context(), token, owner, repo, title, body, nil)
 	if err != nil {
 		slog.Error("failed to create issue", "error", err)
+		if isHTMX(r) {
+			w.Header().Set("Content-Type", "text/html; charset=utf-8")
+			w.WriteHeader(http.StatusInternalServerError)
+			fmt.Fprint(w, `<span class="empty">Failed to create issue. Please try again.</span>`)
+			return
+		}
 		http.Error(w, "failed to create issue", http.StatusInternalServerError)
 		return
 	}

internal/templates/create_issue.html

@@ -1,7 +1,9 @@
 {{define "content"}}
 <h1>Create Issue</h1>
 
-<form hx-post="/issues" hx-swap="innerHTML" hx-target="#main-content">
+<div id="form-error" class="empty" style="display:none;"></div>
+
+<form id="create-issue-form" hx-post="/issues" hx-swap="innerHTML" hx-target="#main-content">
   <div class="form-group">
     <label for="repo-select">Repository</label>
     <select id="repo-select" name="owner_repo" required>
@@ -32,11 +34,43 @@
 </form>
 
 <script>
-  // Split owner/repo from select into hidden fields.
+  (function() {
-  document.getElementById('repo-select').addEventListener('change', function() {
+    var repoSelect = document.getElementById('repo-select');
-    var parts = this.value.split('/');
+    var ownerInput = document.getElementById('owner-input');
-    document.getElementById('owner-input').value = parts[0] || '';
+    var repoInput = document.getElementById('repo-input');
-    document.getElementById('repo-input').value = parts[1] || '';
+    var formError = document.getElementById('form-error');
+
+    function splitOwnerRepo() {
+      var val = repoSelect.value;
+      if (val) {
+        var parts = val.split('/');
+        ownerInput.value = parts[0] || '';
+        repoInput.value = parts[1] || '';
+      } else {
+        ownerInput.value = '';
+        repoInput.value = '';
+      }
+    }
+
+    repoSelect.addEventListener('change', splitOwnerRepo);
+
+    // Validate before HTMX submit.
+    document.getElementById('create-issue-form').addEventListener('htmx:configRequest', function(evt) {
+      splitOwnerRepo();
+      if (!ownerInput.value || !repoInput.value) {
+        evt.preventDefault();
+        formError.textContent = 'Please select a repository before submitting.';
+        formError.style.display = 'block';
+        return false;
+      }
+      formError.style.display = 'none';
     });
+
+    // Show server-side errors inline on HTMX error responses.
+    document.getElementById('create-issue-form').addEventListener('htmx:responseError', function(evt) {
+      formError.textContent = evt.detail.xhr.responseText || 'An error occurred. Please try again.';
+      formError.style.display = 'block';
+    });
+  })();
 </script>
 {{end}}

internal/templates/issue_detail.html

@@ -9,7 +9,9 @@
     <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
     {{end}}
   </div>
-  {{if .Issue.Body}}
+  {{if .RenderedBody}}
+  <div class="card-body markdown-body">{{.RenderedBody}}</div>
+  {{else if .Issue.Body}}
   <div class="card-body">{{.Issue.Body}}</div>
   {{end}}
 </div>

internal/templates/pull_detail.html

@@ -15,7 +15,9 @@
     <span class="diff-del">-{{.Pull.Deletions}}</span>
     {{if .Pull.Mergeable}}<span style="color:var(--accent-green);">Mergeable</span>{{end}}
   </div>
-  {{if .Pull.Body}}
+  {{if .RenderedBody}}
+  <div class="card-body markdown-body">{{.RenderedBody}}</div>
+  {{else if .Pull.Body}}
   <div class="card-body">{{.Pull.Body}}</div>
   {{end}}
 </div>