fix: validate owner/repo split in create_issue.html before submission

Add client-side validation to ensure a repository is selected before
form submission. Split owner/repo on both change and submit events.
Show inline error messages via form-error div. Update CreateIssue
handler to return HTMX-friendly HTML error fragments on 400/500.

Closes leeworks-agents/gitea-mobile#30

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

internal/gitea/client.go

@@ -308,243 +308,173 @@ func (c *Client) ListOrgsAndRepos(ctx context.Context, token string) (map[string
 	return result, nil
 }
 
-// PageSize is the number of items returned per page for paginated listings.
+// ListAllIssues fetches all open issues across all repos in the given orgs,
-const PageSize = 20
+// using concurrent requests with a semaphore.
-
+func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string) ([]Issue, error) {
-// PaginatedIssues holds a page of issues along with pagination metadata.
+	cacheKey := fmt.Sprintf("issues-%s", strings.Join(orgs, ","))
-type PaginatedIssues struct {
+	if cached, ok := c.getFromCache(cacheKey); ok {
-	Issues  []Issue
+		return cached.([]Issue), nil
-	HasMore bool
-}
-
-// PaginatedPulls holds a page of pull requests along with pagination metadata.
-type PaginatedPulls struct {
-	Pulls   []PullRequest
-	HasMore bool
-}
-
-// ListAllIssues fetches issues across all repos in the given orgs,
-// using concurrent requests with a semaphore. Results are paginated.
-func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string, state string, page int) (PaginatedIssues, error) {
-	if state == "" {
-		state = "open"
-	}
-	if page < 1 {
-		page = 1
 	}
 
-	cacheKey := fmt.Sprintf("issues-%s-%s", state, strings.Join(orgs, ","))
+	// First, collect all repos for the given orgs.
+	var allRepos []Repo
+	for _, org := range orgs {
+		repos, err := c.ListOrgRepos(ctx, token, org)
+		if err != nil {
+			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
+		}
+		allRepos = append(allRepos, repos...)
+	}
+
+	// Fan out issue fetching across repos.
 	var allIssues []Issue
-	if cached, ok := c.getFromCache(cacheKey); ok {
+	var mu sync.Mutex
-		allIssues = cached.([]Issue)
+	sem := make(chan struct{}, c.maxConcurrent)
-	} else {
+	var wg sync.WaitGroup
-		// First, collect all repos for the given orgs.
+	var firstErr error
-		var allRepos []Repo
+
-		for _, org := range orgs {
+	for _, repo := range allRepos {
-			repos, err := c.ListOrgRepos(ctx, token, org)
+		wg.Add(1)
+		go func(r Repo) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			path := fmt.Sprintf("/repos/%s/issues?state=open&type=issues&limit=50", r.FullName)
+			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
 			if err != nil {
-				return PaginatedIssues{}, fmt.Errorf("listing repos for %s: %w", org, err)
-			}
-			allRepos = append(allRepos, repos...)
-		}
-
-		// Fan out issue fetching across repos.
-		var mu sync.Mutex
-		sem := make(chan struct{}, c.maxConcurrent)
-		var wg sync.WaitGroup
-		var firstErr error
-
-		for _, repo := range allRepos {
-			wg.Add(1)
-			go func(r Repo) {
-				defer wg.Done()
-				sem <- struct{}{}
-				defer func() { <-sem }()
-
-				path := fmt.Sprintf("/repos/%s/issues?state=%s&type=issues&limit=50", r.FullName, state)
-				resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
-				if err != nil {
-					mu.Lock()
-					if firstErr == nil {
-						firstErr = fmt.Errorf("fetching issues for %s: %w", r.FullName, err)
-					}
-					mu.Unlock()
-					return
-				}
-				defer resp.Body.Close()
-
-				var issues []Issue
-				if err := json.NewDecoder(resp.Body).Decode(&issues); err != nil {
-					mu.Lock()
-					if firstErr == nil {
-						firstErr = fmt.Errorf("decoding issues for %s: %w", r.FullName, err)
-					}
-					mu.Unlock()
-					return
-				}
-
-				// Tag each issue with repo info.
-				for i := range issues {
-					issues[i].RepoOwner = r.Owner.Login
-					issues[i].RepoName = r.Name
-				}
-
 				mu.Lock()
-				allIssues = append(allIssues, issues...)
+				if firstErr == nil {
+					firstErr = fmt.Errorf("fetching issues for %s: %w", r.FullName, err)
+				}
 				mu.Unlock()
-			}(repo)
+				return
-		}
+			}
+			defer resp.Body.Close()
 
-		wg.Wait()
+			var issues []Issue
+			if err := json.NewDecoder(resp.Body).Decode(&issues); err != nil {
+				mu.Lock()
+				if firstErr == nil {
+					firstErr = fmt.Errorf("decoding issues for %s: %w", r.FullName, err)
+				}
+				mu.Unlock()
+				return
+			}
 
-		if firstErr != nil {
+			// Tag each issue with repo info.
-			return PaginatedIssues{}, firstErr
+			for i := range issues {
-		}
+				issues[i].RepoOwner = r.Owner.Login
+				issues[i].RepoName = r.Name
+			}
 
-		// Sort by updated time, newest first.
+			mu.Lock()
-		sort.Slice(allIssues, func(i, j int) bool {
+			allIssues = append(allIssues, issues...)
-			return allIssues[i].UpdatedAt.After(allIssues[j].UpdatedAt)
+			mu.Unlock()
-		})
+		}(repo)
-
-		c.setCache(cacheKey, allIssues)
 	}
 
-	// Paginate.
+	wg.Wait()
-	start := (page - 1) * PageSize
+
-	if start >= len(allIssues) {
+	if firstErr != nil {
-		return PaginatedIssues{}, nil
+		return nil, firstErr
-	}
-	end := start + PageSize
-	hasMore := end < len(allIssues)
-	if end > len(allIssues) {
-		end = len(allIssues)
 	}
 
-	return PaginatedIssues{Issues: allIssues[start:end], HasMore: hasMore}, nil
+	// Sort by updated time, newest first.
+	sort.Slice(allIssues, func(i, j int) bool {
+		return allIssues[i].UpdatedAt.After(allIssues[j].UpdatedAt)
+	})
+
+	c.setCache(cacheKey, allIssues)
+	return allIssues, nil
 }
 
-// ListAllPullRequests fetches PRs across all repos in the given orgs.
+// ListAllPullRequests fetches all open PRs across all repos in the given orgs.
-// Results are paginated.
+func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string) ([]PullRequest, error) {
-func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string, state string, page int) (PaginatedPulls, error) {
+	cacheKey := fmt.Sprintf("pulls-%s", strings.Join(orgs, ","))
-	if state == "" {
-		state = "open"
-	}
-	if page < 1 {
-		page = 1
-	}
-
-	cacheKey := fmt.Sprintf("pulls-%s-%s", state, strings.Join(orgs, ","))
-	var allPRs []PullRequest
 	if cached, ok := c.getFromCache(cacheKey); ok {
-		allPRs = cached.([]PullRequest)
+		return cached.([]PullRequest), nil
-	} else {
+	}
-		var allRepos []Repo
+
-		for _, org := range orgs {
+	var allRepos []Repo
-			repos, err := c.ListOrgRepos(ctx, token, org)
+	for _, org := range orgs {
+		repos, err := c.ListOrgRepos(ctx, token, org)
+		if err != nil {
+			return nil, fmt.Errorf("listing repos for %s: %w", org, err)
+		}
+		allRepos = append(allRepos, repos...)
+	}
+
+	var allPRs []PullRequest
+	var mu sync.Mutex
+	sem := make(chan struct{}, c.maxConcurrent)
+	var wg sync.WaitGroup
+	var firstErr error
+
+	for _, repo := range allRepos {
+		wg.Add(1)
+		go func(r Repo) {
+			defer wg.Done()
+			sem <- struct{}{}
+			defer func() { <-sem }()
+
+			path := fmt.Sprintf("/repos/%s/pulls?state=open&limit=50", r.FullName)
+			resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
 			if err != nil {
-				return PaginatedPulls{}, fmt.Errorf("listing repos for %s: %w", org, err)
-			}
-			allRepos = append(allRepos, repos...)
-		}
-
-		var mu sync.Mutex
-		sem := make(chan struct{}, c.maxConcurrent)
-		var wg sync.WaitGroup
-		var firstErr error
-
-		for _, repo := range allRepos {
-			wg.Add(1)
-			go func(r Repo) {
-				defer wg.Done()
-				sem <- struct{}{}
-				defer func() { <-sem }()
-
-				path := fmt.Sprintf("/repos/%s/pulls?state=%s&limit=50", r.FullName, state)
-				resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
-				if err != nil {
-					mu.Lock()
-					if firstErr == nil {
-						firstErr = fmt.Errorf("fetching PRs for %s: %w", r.FullName, err)
-					}
-					mu.Unlock()
-					return
-				}
-				defer resp.Body.Close()
-
-				var prs []PullRequest
-				if err := json.NewDecoder(resp.Body).Decode(&prs); err != nil {
-					mu.Lock()
-					if firstErr == nil {
-						firstErr = fmt.Errorf("decoding PRs for %s: %w", r.FullName, err)
-					}
-					mu.Unlock()
-					return
-				}
-
-				for i := range prs {
-					prs[i].RepoOwner = r.Owner.Login
-					prs[i].RepoName = r.Name
-				}
-
 				mu.Lock()
-				allPRs = append(allPRs, prs...)
+				if firstErr == nil {
+					firstErr = fmt.Errorf("fetching PRs for %s: %w", r.FullName, err)
+				}
 				mu.Unlock()
-			}(repo)
+				return
-		}
+			}
+			defer resp.Body.Close()
 
-		wg.Wait()
+			var prs []PullRequest
+			if err := json.NewDecoder(resp.Body).Decode(&prs); err != nil {
+				mu.Lock()
+				if firstErr == nil {
+					firstErr = fmt.Errorf("decoding PRs for %s: %w", r.FullName, err)
+				}
+				mu.Unlock()
+				return
+			}
 
-		if firstErr != nil {
+			for i := range prs {
-			return PaginatedPulls{}, firstErr
+				prs[i].RepoOwner = r.Owner.Login
-		}
+				prs[i].RepoName = r.Name
+			}
 
-		sort.Slice(allPRs, func(i, j int) bool {
+			mu.Lock()
-			return allPRs[i].UpdatedAt.After(allPRs[j].UpdatedAt)
+			allPRs = append(allPRs, prs...)
-		})
+			mu.Unlock()
-
+		}(repo)
-		c.setCache(cacheKey, allPRs)
 	}
 
-	// Paginate.
+	wg.Wait()
-	start := (page - 1) * PageSize
+
-	if start >= len(allPRs) {
+	if firstErr != nil {
-		return PaginatedPulls{}, nil
+		return nil, firstErr
-	}
-	end := start + PageSize
-	hasMore := end < len(allPRs)
-	if end > len(allPRs) {
-		end = len(allPRs)
 	}
 
-	return PaginatedPulls{Pulls: allPRs[start:end], HasMore: hasMore}, nil
+	sort.Slice(allPRs, func(i, j int) bool {
+		return allPRs[i].UpdatedAt.After(allPRs[j].UpdatedAt)
+	})
+
+	c.setCache(cacheKey, allPRs)
+	return allPRs, nil
 }
 
 // GetTriageQueue returns unassigned issues and PRs needing review, sorted by priority.
 func (c *Client) GetTriageQueue(ctx context.Context, token string, orgs []string) ([]TriageItem, error) {
-	// Collect all open issues across all pages.
+	issues, err := c.ListAllIssues(ctx, token, orgs)
-	var issues []Issue
+	if err != nil {
-	for page := 1; ; page++ {
+		return nil, fmt.Errorf("fetching issues for triage: %w", err)
-		result, err := c.ListAllIssues(ctx, token, orgs, "open", page)
-		if err != nil {
-			return nil, fmt.Errorf("fetching issues for triage: %w", err)
-		}
-		issues = append(issues, result.Issues...)
-		if !result.HasMore {
-			break
-		}
 	}
 
-	// Collect all open PRs across all pages.
+	prs, err := c.ListAllPullRequests(ctx, token, orgs)
-	var prs []PullRequest
+	if err != nil {
-	for page := 1; ; page++ {
+		return nil, fmt.Errorf("fetching PRs for triage: %w", err)
-		result, err := c.ListAllPullRequests(ctx, token, orgs, "open", page)
-		if err != nil {
-			return nil, fmt.Errorf("fetching PRs for triage: %w", err)
-		}
-		prs = append(prs, result.Pulls...)
-		if !result.HasMore {
-			break
-		}
 	}
 
 	var queue []TriageItem
@@ -776,90 +706,6 @@ func (c *Client) SubmitReview(ctx context.Context, token, owner, repo string, in
 	return nil
 }
 
-// CloseIssue closes an issue by setting its state to "closed".
-func (c *Client) CloseIssue(ctx context.Context, token, owner, repo string, index int64) error {
-	payload, err := json.Marshal(map[string]string{"state": "closed"})
-	if err != nil {
-		return fmt.Errorf("marshaling close request: %w", err)
-	}
-
-	path := fmt.Sprintf("/repos/%s/%s/issues/%d", owner, repo, index)
-	resp, err := c.doRequest(ctx, token, http.MethodPatch, path, strings.NewReader(string(payload)))
-	if err != nil {
-		return fmt.Errorf("closing issue: %w", err)
-	}
-	resp.Body.Close()
-
-	c.InvalidateAll()
-	return nil
-}
-
-// PostComment creates a comment on an issue and returns the created Comment.
-func (c *Client) PostComment(ctx context.Context, token, owner, repo string, index int64, body string) (*Comment, error) {
-	payload, err := json.Marshal(map[string]string{"body": body})
-	if err != nil {
-		return nil, fmt.Errorf("marshaling comment: %w", err)
-	}
-
-	path := fmt.Sprintf("/repos/%s/%s/issues/%d/comments", owner, repo, index)
-	resp, err := c.doRequest(ctx, token, http.MethodPost, path, strings.NewReader(string(payload)))
-	if err != nil {
-		return nil, fmt.Errorf("posting comment: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var comment Comment
-	if err := json.NewDecoder(resp.Body).Decode(&comment); err != nil {
-		return nil, fmt.Errorf("decoding comment: %w", err)
-	}
-
-	// Populate convenience fields.
-	comment.User = comment.RawUser.Login
-	comment.CreatedAt = comment.RawCreatedAt.Format("Jan 2, 2006 15:04")
-
-	c.InvalidateAll()
-	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/gitea/client_test.go

@@ -201,97 +201,6 @@ func TestGetTriageQueue_Sorting(t *testing.T) {
 	}
 }
 
-func TestCloseIssue(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPatch {
-			t.Errorf("expected PATCH, got %s", r.Method)
-		}
-		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-		if r.Header.Get("Authorization") != "token test-token" {
-			t.Error("missing or wrong Authorization header")
-		}
-
-		var body map[string]string
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("failed to decode body: %v", err)
-		}
-		if body["state"] != "closed" {
-			t.Errorf("expected state=closed, got %q", body["state"])
-		}
-
-		w.WriteHeader(http.StatusOK)
-		json.NewEncoder(w).Encode(map[string]string{"state": "closed"})
-	}))
-	defer server.Close()
-
-	c := NewClient(server.URL)
-	c.setCache("issues-org1", "should-be-invalidated")
-
-	err := c.CloseIssue(context.Background(), "test-token", "owner1", "repo1", 42)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	// Verify cache was invalidated.
-	_, ok := c.getFromCache("issues-org1")
-	if ok {
-		t.Error("expected cache to be invalidated after CloseIssue")
-	}
-}
-
-func TestPostComment(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPost {
-			t.Errorf("expected POST, got %s", r.Method)
-		}
-		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/comments" {
-			t.Errorf("unexpected path: %s", r.URL.Path)
-		}
-
-		var body map[string]string
-		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
-			t.Fatalf("failed to decode body: %v", err)
-		}
-		if body["body"] != "test comment" {
-			t.Errorf("expected body='test comment', got %q", body["body"])
-		}
-
-		comment := map[string]interface{}{
-			"id":   1,
-			"body": body["body"],
-			"user": map[string]string{"login": "testuser"},
-			"created_at": "2026-03-26T12:00:00Z",
-		}
-		json.NewEncoder(w).Encode(comment)
-	}))
-	defer server.Close()
-
-	c := NewClient(server.URL)
-	c.setCache("issues-org1", "should-be-invalidated")
-
-	comment, err := c.PostComment(context.Background(), "test-token", "owner1", "repo1", 42, "test comment")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if comment.Body != "test comment" {
-		t.Errorf("comment.Body = %q, want %q", comment.Body, "test comment")
-	}
-	if comment.User != "testuser" {
-		t.Errorf("comment.User = %q, want %q", comment.User, "testuser")
-	}
-	if comment.ID != 1 {
-		t.Errorf("comment.ID = %d, want 1", comment.ID)
-	}
-
-	// Verify cache was invalidated.
-	_, ok := c.getFromCache("issues-org1")
-	if ok {
-		t.Error("expected cache to be invalidated after PostComment")
-	}
-}
-
 // sortTriageQueue is a test helper applying the same sort as GetTriageQueue.
 func sortTriageQueue(queue []TriageItem) {
 	for i := 0; i < len(queue); i++ {

internal/handlers/handlers.go

@@ -38,11 +38,8 @@ 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)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comment", h.AddComment)
 
 	// Issue detail.
 	mux.HandleFunc("GET /issues/{owner}/{repo}/{index}", h.IssueDetail)
@@ -183,211 +180,158 @@ func (h *Handler) Dashboard(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)
 	orgs := h.getUserOrgs(r)
 
-	type dashboardData struct {
-		Items []giteaclient.TriageItem
-		Error string
-	}
-
-	var data dashboardData
-
 	if len(orgs) == 0 {
-		data.Error = "No organizations found. Check your token permissions."
+		renderPage(w, r, "Dashboard", "dashboard",
-	} else {
+			`<h1>Dashboard</h1><p class="empty">No organizations found. Check your token permissions.</p>`)
-		queue, err := h.Client.GetTriageQueue(r.Context(), token, orgs)
+		return
-		if err != nil {
-			slog.Error("failed to get triage queue", "error", err)
-			data.Error = "Error loading triage queue."
-		} else {
-			data.Items = queue
-		}
 	}
 
-	tmpl, err := template.ParseFiles("internal/templates/dashboard.html")
+	queue, err := h.Client.GetTriageQueue(r.Context(), token, orgs)
 	if err != nil {
-		slog.Error("failed to parse dashboard template", "error", err)
+		slog.Error("failed to get triage queue", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+		renderPage(w, r, "Dashboard", "dashboard",
+			`<h1>Dashboard</h1><p class="empty">Error loading triage queue.</p>`)
 		return
 	}
 
-	var buf strings.Builder
+	if len(queue) == 0 {
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
+		renderPage(w, r, "Dashboard", "dashboard",
-		slog.Error("failed to execute dashboard template", "error", err)
+			`<h1>Dashboard</h1><p class="empty">No items need attention. Nice work!</p>`)
-		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	renderPage(w, r, "Dashboard", "dashboard", buf.String())
+	content := `<h1>Dashboard</h1>`
+	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)
-	orgNames := h.getUserOrgs(r)
+	orgs := h.getUserOrgs(r)
 
-	type issuesData struct {
+	if len(orgs) == 0 {
-		Issues        []giteaclient.Issue
+		renderPage(w, r, "Issues", "issues",
-		Orgs          []string
+			`<h1>Issues</h1><p class="empty">No organizations found.</p>`)
-		SelectedOrg   string
-		SelectedState string
-		HasMore       bool
-		NextPage      int
-		Error         string
-	}
-
-	selectedOrg := r.URL.Query().Get("org")
-	selectedState := r.URL.Query().Get("state")
-	if selectedState == "" {
-		selectedState = "open"
-	}
-	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
-	if page < 1 {
-		page = 1
-	}
-
-	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}
-		}
-
-		result, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs, selectedState, page)
-		if err != nil {
-			slog.Error("failed to list issues", "error", err)
-			data.Error = "Error loading issues."
-		} else {
-			data.Issues = result.Issues
-			data.HasMore = result.HasMore
-			if result.HasMore {
-				data.NextPage = page + 1
-			}
-		}
-	}
-
-	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
-	if isHTMX(r) && page > 1 {
-		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
-		}
-		var buf strings.Builder
-		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
-			slog.Error("failed to execute issues cards template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, buf.String())
 		return
 	}
 
-	tmpl, err := template.ParseFiles("internal/templates/issues.html")
+	issues, err := h.Client.ListAllIssues(r.Context(), token, orgs)
 	if err != nil {
-		slog.Error("failed to parse issues template", "error", err)
+		slog.Error("failed to list issues", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+		renderPage(w, r, "Issues", "issues",
+			`<h1>Issues</h1><p class="empty">Error loading issues.</p>`)
 		return
 	}
 
-	var buf strings.Builder
+	if len(issues) == 0 {
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
+		renderPage(w, r, "Issues", "issues",
-		slog.Error("failed to execute issues template", "error", err)
+			`<h1>Issues</h1><p class="empty">No open issues found.</p>`)
-		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	renderPage(w, r, "Issues", "issues", buf.String())
+	content := `<h1>Issues</h1>`
+	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)
-	orgNames := h.getUserOrgs(r)
+	orgs := h.getUserOrgs(r)
 
-	type pullsData struct {
+	if len(orgs) == 0 {
-		Pulls       []giteaclient.PullRequest
+		renderPage(w, r, "Pull Requests", "pulls",
-		Orgs        []string
+			`<h1>Pull Requests</h1><p class="empty">No organizations found.</p>`)
-		SelectedOrg string
-		HasMore     bool
-		NextPage    int
-		Error       string
-	}
-
-	selectedOrg := r.URL.Query().Get("org")
-	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
-	if page < 1 {
-		page = 1
-	}
-
-	data := pullsData{
-		Orgs:        orgNames,
-		SelectedOrg: selectedOrg,
-	}
-
-	if len(orgNames) == 0 {
-		data.Error = "No organizations found."
-	} else {
-		queryOrgs := orgNames
-		if selectedOrg != "" {
-			queryOrgs = []string{selectedOrg}
-		}
-
-		result, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs, "open", page)
-		if err != nil {
-			slog.Error("failed to list pull requests", "error", err)
-			data.Error = "Error loading pull requests."
-		} else {
-			data.Pulls = result.Pulls
-			data.HasMore = result.HasMore
-			if result.HasMore {
-				data.NextPage = page + 1
-			}
-		}
-	}
-
-	// For HTMX infinite-scroll requests (page > 1), return only the card fragment.
-	if isHTMX(r) && page > 1 {
-		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
-		}
-		var buf strings.Builder
-		if err := tmpl.ExecuteTemplate(&buf, "cards", data); err != nil {
-			slog.Error("failed to execute pulls cards template", "error", err)
-			http.Error(w, "template error", http.StatusInternalServerError)
-			return
-		}
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprint(w, buf.String())
 		return
 	}
 
-	tmpl, err := template.ParseFiles("internal/templates/pulls.html")
+	prs, err := h.Client.ListAllPullRequests(r.Context(), token, orgs)
 	if err != nil {
-		slog.Error("failed to parse pulls template", "error", err)
+		slog.Error("failed to list pull requests", "error", err)
-		http.Error(w, "template error", http.StatusInternalServerError)
+		renderPage(w, r, "Pull Requests", "pulls",
+			`<h1>Pull Requests</h1><p class="empty">Error loading pull requests.</p>`)
 		return
 	}
 
-	var buf strings.Builder
+	if len(prs) == 0 {
-	if err := tmpl.ExecuteTemplate(&buf, "content", data); err != nil {
+		renderPage(w, r, "Pull Requests", "pulls",
-		slog.Error("failed to execute pulls template", "error", err)
+			`<h1>Pull Requests</h1><p class="empty">No open pull requests found.</p>`)
-		http.Error(w, "template error", http.StatusInternalServerError)
 		return
 	}
 
-	renderPage(w, r, "Pull Requests", "pulls", buf.String())
+	content := `<h1>Pull Requests</h1>`
+	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}.
@@ -423,17 +367,6 @@ 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 {
@@ -444,14 +377,12 @@ 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,
 	}
@@ -487,17 +418,6 @@ 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 {
@@ -507,13 +427,11 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 	}
 
 	type templateData struct {
-		Pull         *giteaclient.PullRequest
+		Pull *giteaclient.PullRequest
-		RenderedBody template.HTML
 	}
 
 	data := templateData{
-		Pull:         pr,
+		Pull: pr,
-		RenderedBody: renderedBody,
 	}
 
 	var buf strings.Builder
@@ -526,41 +444,6 @@ 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)
@@ -654,77 +537,6 @@ func (h *Handler) ApplyLabels(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
 }
 
-// CloseIssue handles POST /issues/{owner}/{repo}/{index}/close.
-func (h *Handler) CloseIssue(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.CloseIssue(r.Context(), token, owner, repo, index); err != nil {
-		slog.Error("failed to close issue", "error", err, "owner", owner, "repo", repo, "index", index)
-		http.Error(w, "failed to close issue", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("HX-Redirect", fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index))
-		w.WriteHeader(http.StatusOK)
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
-// AddComment handles POST /issues/{owner}/{repo}/{index}/comment.
-func (h *Handler) AddComment(w http.ResponseWriter, r *http.Request) {
-	token := getToken(r)
-	owner := r.PathValue("owner")
-	repo := r.PathValue("repo")
-	indexStr := r.PathValue("index")
-
-	index, err := strconv.ParseInt(indexStr, 10, 64)
-	if err != nil {
-		http.Error(w, "invalid issue index", http.StatusBadRequest)
-		return
-	}
-
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, "bad request", http.StatusBadRequest)
-		return
-	}
-
-	body := r.FormValue("body")
-	if body == "" {
-		http.Error(w, "comment body is required", http.StatusBadRequest)
-		return
-	}
-
-	comment, err := h.Client.PostComment(r.Context(), token, owner, repo, index, body)
-	if err != nil {
-		slog.Error("failed to post comment", "error", err, "owner", owner, "repo", repo, "index", index)
-		http.Error(w, "failed to post comment", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprintf(w, `<div class="card comment">
-  <div class="card-meta">%s &middot; %s</div>
-  <div class="card-body">%s</div>
-</div>`, template.HTMLEscapeString(comment.User), template.HTMLEscapeString(comment.CreatedAt), template.HTMLEscapeString(comment.Body))
-		return
-	}
-
-	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
-}
-
 // SubmitReview handles POST /pulls/{owner}/{repo}/{index}/review.
 func (h *Handler) SubmitReview(w http.ResponseWriter, r *http.Request) {
 	token := getToken(r)

internal/templates/issue_detail.html

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

internal/templates/issues.html

@@ -1,25 +1,3 @@
-{{define "cards"}}
-  {{range .Issues}}
-  <div class="card" hx-get="/issues/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
-    <div class="card-title">{{.Title}}</div>
-    <div class="card-meta">
-      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
-      {{range .Labels}}
-      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
-      {{end}}
-      {{if .Assignee}}
-      <span>{{.Assignee.Login}}</span>
-      {{end}}
-    </div>
-  </div>
-  {{end}}
-  {{if .HasMore}}
-  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
-    <div class="spinner htmx-indicator"></div>
-  </div>
-  {{end}}
-{{end}}
-
 {{define "content"}}
 <h1>Issues</h1>
 
@@ -42,7 +20,25 @@
 <p class="empty">No issues found.</p>
 {{else}}
 <div id="issue-list">
-  {{template "cards" .}}
+  {{range .Issues}}
+  <div class="card" hx-get="/issues/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
+    <div class="card-title">{{.Title}}</div>
+    <div class="card-meta">
+      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
+      {{range .Labels}}
+      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
+      {{end}}
+      {{if .Assignee}}
+      <span>{{.Assignee.Login}}</span>
+      {{end}}
+    </div>
+  </div>
+  {{end}}
+  {{if .HasMore}}
+  <div class="scroll-sentinel" hx-get="/issues?page={{.NextPage}}&org={{.SelectedOrg}}&state={{.SelectedState}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
+    <div class="spinner htmx-indicator"></div>
+  </div>
+  {{end}}
 </div>
 {{end}}
 {{end}}

internal/templates/pull_detail.html

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

internal/templates/pulls.html

@@ -1,28 +1,3 @@
-{{define "cards"}}
-  {{range .Pulls}}
-  <div class="card" hx-get="/pulls/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
-    <div class="card-title">
-      <span class="type-badge type-pull">PR</span>
-      {{.Title}}
-    </div>
-    <div class="card-meta">
-      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
-      {{range .Labels}}
-      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
-      {{end}}
-      <span class="diff-add">+{{.Additions}}</span>
-      <span class="diff-del">-{{.Deletions}}</span>
-      {{if .Mergeable}}<span style="color:var(--accent-green);font-size:0.7rem;">mergeable</span>{{end}}
-    </div>
-  </div>
-  {{end}}
-  {{if .HasMore}}
-  <div class="scroll-sentinel" hx-get="/pulls?page={{.NextPage}}&org={{.SelectedOrg}}" hx-trigger="revealed" hx-swap="outerHTML" hx-target="this">
-    <div class="spinner htmx-indicator"></div>
-  </div>
-  {{end}}
-{{end}}
-
 {{define "content"}}
 <h1>Pull Requests</h1>
 
@@ -41,7 +16,23 @@
 <p class="empty">No open pull requests found.</p>
 {{else}}
 <div id="pull-list">
-  {{template "cards" .}}
+  {{range .Pulls}}
+  <div class="card" hx-get="/pulls/{{.RepoOwner}}/{{.RepoName}}/{{.Number}}" hx-target="#main-content" hx-swap="innerHTML" hx-push-url="true">
+    <div class="card-title">
+      <span class="type-badge type-pull">PR</span>
+      {{.Title}}
+    </div>
+    <div class="card-meta">
+      <span>{{.RepoOwner}}/{{.RepoName}} #{{.Number}}</span>
+      {{range .Labels}}
+      <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
+      {{end}}
+      <span class="diff-add">+{{.Additions}}</span>
+      <span class="diff-del">-{{.Deletions}}</span>
+      {{if .Mergeable}}<span style="color:var(--accent-green);font-size:0.7rem;">mergeable</span>{{end}}
+    </div>
+  </div>
+  {{end}}
 </div>
 {{end}}
 {{end}}