refactor: wire Dashboard, ListIssues, and ListPulls to use template files

Replace inline fmt.Sprintf HTML generation in Dashboard, ListIssues,
and ListPulls handlers with template.ParseFiles rendering of
dashboard.html, issues.html, and pulls.html respectively.

ListIssues now reads ?org= and ?state= query params to filter results.
ListPulls now reads ?org= query param to filter results.

Closes leeworks-agents/gitea-mobile#34

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.
-const PageSize = 20
-
-// PaginatedIssues holds a page of issues along with pagination metadata.
-type PaginatedIssues struct {
-	Issues  []Issue
-	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
+// ListAllIssues fetches all open issues across all repos in the given orgs,
+// using concurrent requests with a semaphore.
+func (c *Client) ListAllIssues(ctx context.Context, token string, orgs []string) ([]Issue, error) {
+	cacheKey := fmt.Sprintf("issues-%s", strings.Join(orgs, ","))
+	if cached, ok := c.getFromCache(cacheKey); ok {
+		return cached.([]Issue), nil
 	}
 
-	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 {
-		allIssues = cached.([]Issue)
-	} else {
-		// First, collect all repos for the given orgs.
-		var allRepos []Repo
-		for _, org := range orgs {
-			repos, err := c.ListOrgRepos(ctx, token, org)
+	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=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 {
-			return PaginatedIssues{}, firstErr
-		}
+			// Tag each issue with repo info.
+			for i := range issues {
+				issues[i].RepoOwner = r.Owner.Login
+				issues[i].RepoName = r.Name
+			}
 
-		// 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)
+			mu.Lock()
+			allIssues = append(allIssues, issues...)
+			mu.Unlock()
+		}(repo)
 	}
 
-	// Paginate.
-	start := (page - 1) * PageSize
-	if start >= len(allIssues) {
-		return PaginatedIssues{}, nil
-	}
-	end := start + PageSize
-	hasMore := end < len(allIssues)
-	if end > len(allIssues) {
-		end = len(allIssues)
+	wg.Wait()
+
+	if firstErr != nil {
+		return nil, firstErr
 	}
 
-	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.
-// Results are paginated.
-func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string, state string, page int) (PaginatedPulls, error) {
-	if state == "" {
-		state = "open"
-	}
-	if page < 1 {
-		page = 1
-	}
-
-	cacheKey := fmt.Sprintf("pulls-%s-%s", state, strings.Join(orgs, ","))
-	var allPRs []PullRequest
+// ListAllPullRequests fetches all open PRs across all repos in the given orgs.
+func (c *Client) ListAllPullRequests(ctx context.Context, token string, orgs []string) ([]PullRequest, error) {
+	cacheKey := fmt.Sprintf("pulls-%s", strings.Join(orgs, ","))
 	if cached, ok := c.getFromCache(cacheKey); ok {
-		allPRs = cached.([]PullRequest)
-	} else {
-		var allRepos []Repo
-		for _, org := range orgs {
-			repos, err := c.ListOrgRepos(ctx, token, org)
+		return cached.([]PullRequest), nil
+	}
+
+	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...)
+	}
+
+	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 {
-			return PaginatedPulls{}, firstErr
-		}
+			for i := range prs {
+				prs[i].RepoOwner = r.Owner.Login
+				prs[i].RepoName = r.Name
+			}
 
-		sort.Slice(allPRs, func(i, j int) bool {
-			return allPRs[i].UpdatedAt.After(allPRs[j].UpdatedAt)
-		})
-
-		c.setCache(cacheKey, allPRs)
+			mu.Lock()
+			allPRs = append(allPRs, prs...)
+			mu.Unlock()
+		}(repo)
 	}
 
-	// Paginate.
-	start := (page - 1) * PageSize
-	if start >= len(allPRs) {
-		return PaginatedPulls{}, nil
-	}
-	end := start + PageSize
-	hasMore := end < len(allPRs)
-	if end > len(allPRs) {
-		end = len(allPRs)
+	wg.Wait()
+
+	if firstErr != nil {
+		return nil, firstErr
 	}
 
-	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.
-	var issues []Issue
-	for page := 1; ; page++ {
-		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
-		}
+	issues, err := c.ListAllIssues(ctx, token, orgs)
+	if err != nil {
+		return nil, fmt.Errorf("fetching issues for triage: %w", err)
 	}
 
-	// Collect all open PRs across all pages.
-	var prs []PullRequest
-	for page := 1; ; page++ {
-		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
-		}
+	prs, err := c.ListAllPullRequests(ctx, token, orgs)
+	if err != nil {
+		return nil, fmt.Errorf("fetching PRs for triage: %w", err)
 	}
 
 	var queue []TriageItem
@@ -753,49 +683,6 @@ func (c *Client) ApplyLabel(ctx context.Context, token, owner, repo string, inde
 	return nil
 }
 
-// ListCollaborators fetches the list of collaborators (users with access) for a repo.
-func (c *Client) ListCollaborators(ctx context.Context, token, owner, repo string) ([]string, error) {
-	path := fmt.Sprintf("/repos/%s/%s/collaborators?limit=50", owner, repo)
-	resp, err := c.doRequest(ctx, token, http.MethodGet, path, nil)
-	if err != nil {
-		return nil, fmt.Errorf("fetching collaborators: %w", err)
-	}
-	defer resp.Body.Close()
-
-	var users []struct {
-		Login string `json:"login"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&users); err != nil {
-		return nil, fmt.Errorf("decoding collaborators: %w", err)
-	}
-
-	var logins []string
-	for _, u := range users {
-		logins = append(logins, u.Login)
-	}
-	return logins, nil
-}
-
-// AssignIssue sets the assignees on an issue.
-func (c *Client) AssignIssue(ctx context.Context, token, owner, repo string, index int64, assignees []string) error {
-	payload, err := json.Marshal(map[string]interface{}{
-		"assignees": assignees,
-	})
-	if err != nil {
-		return fmt.Errorf("marshaling assignees: %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("assigning issue: %w", err)
-	}
-	resp.Body.Close()
-
-	c.InvalidateAll()
-	return nil
-}
-
 // SubmitReview submits a review on a pull request.
 func (c *Client) SubmitReview(ctx context.Context, token, owner, repo string, index int64, reviewType, body string) error {
 	payload := map[string]interface{}{
@@ -821,20 +708,15 @@ func (c *Client) SubmitReview(ctx context.Context, token, owner, repo string, in
 
 // CloseIssue closes an issue by setting its state to "closed".
 func (c *Client) CloseIssue(ctx context.Context, token, owner, repo string, index int64) error {
-	return c.SetIssueState(ctx, token, owner, repo, index, "closed")
-}
-
-// SetIssueState sets an issue's state (e.g. "open" or "closed").
-func (c *Client) SetIssueState(ctx context.Context, token, owner, repo string, index int64, state string) error {
-	payload, err := json.Marshal(map[string]string{"state": state})
+	payload, err := json.Marshal(map[string]string{"state": "closed"})
 	if err != nil {
-		return fmt.Errorf("marshaling state change: %w", err)
+		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("setting issue state: %w", err)
+		return fmt.Errorf("closing issue: %w", err)
 	}
 	resp.Body.Close()
 
@@ -842,11 +724,6 @@ func (c *Client) SetIssueState(ctx context.Context, token, owner, repo string, i
 	return nil
 }
 
-// AddComment creates a comment on an issue and returns the created Comment.
-func (c *Client) AddComment(ctx context.Context, token, owner, repo string, index int64, body string) (*Comment, error) {
-	return c.PostComment(ctx, token, owner, repo, index, body)
-}
-
 // 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})
@@ -874,45 +751,6 @@ 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/gitea/client_test.go

@@ -241,76 +241,6 @@ func TestCloseIssue(t *testing.T) {
 	}
 }
 
-func TestSetIssueState(t *testing.T) {
-	tests := []struct {
-		name  string
-		state string
-	}{
-		{"close", "closed"},
-		{"reopen", "open"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(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)
-				}
-
-				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"] != tt.state {
-					t.Errorf("expected state=%q, got %q", tt.state, body["state"])
-				}
-
-				w.WriteHeader(http.StatusOK)
-				json.NewEncoder(w).Encode(map[string]string{"state": tt.state})
-			}))
-			defer server.Close()
-
-			c := NewClient(server.URL)
-			c.setCache("issues-org1", "should-be-invalidated")
-
-			err := c.SetIssueState(context.Background(), "test-token", "owner1", "repo1", 42, tt.state)
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-
-			_, ok := c.getFromCache("issues-org1")
-			if ok {
-				t.Error("expected cache to be invalidated after SetIssueState")
-			}
-		})
-	}
-}
-
-func TestAddComment(t *testing.T) {
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		comment := map[string]interface{}{
-			"id":         1,
-			"body":       "test",
-			"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)
-	comment, err := c.AddComment(context.Background(), "test-token", "owner1", "repo1", 42, "test")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if comment.Body != "test" {
-		t.Errorf("comment.Body = %q, want %q", comment.Body, "test")
-	}
-}
-
 func TestPostComment(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodPost {

internal/handlers/handlers.go

@@ -38,13 +38,9 @@ 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}/assignees", h.AssignIssue)
 	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/close", h.CloseIssue)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comments", h.AddComment)
 	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comment", h.AddComment)
 
 	// Issue detail.
@@ -118,10 +114,6 @@ var basePage = template.Must(template.New("base").Parse(`<!DOCTYPE html>
   <script src="/static/htmx.min.js"></script>
 </head>
 <body>
-  <header class="top-bar">
-    <span class="top-bar-title">Gitea Mobile</span>
-    <button class="refresh-btn" hx-get="" hx-target="#main-content" hx-swap="innerHTML" aria-label="Refresh">&#8635;</button>
-  </header>
   <div class="content" id="main-content">
     {{.Content}}
   </div>
@@ -246,10 +238,6 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 	if selectedState == "" {
 		selectedState = "open"
 	}
-	page, _ := strconv.Atoi(r.URL.Query().Get("page"))
-	if page < 1 {
-		page = 1
-	}
 
 	data := issuesData{
 		Orgs:          orgNames,
@@ -266,38 +254,15 @@ func (h *Handler) ListIssues(w http.ResponseWriter, r *http.Request) {
 			queryOrgs = []string{selectedOrg}
 		}
 
-		result, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs, selectedState, page)
+		issues, err := h.Client.ListAllIssues(r.Context(), token, queryOrgs)
 		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
-			}
+			data.Issues = issues
 		}
 	}
 
-	// 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")
 	if err != nil {
 		slog.Error("failed to parse issues template", "error", err)
@@ -324,16 +289,10 @@ func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 		Pulls       []giteaclient.PullRequest
 		Orgs        []string
 		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,
@@ -348,38 +307,15 @@ func (h *Handler) ListPulls(w http.ResponseWriter, r *http.Request) {
 			queryOrgs = []string{selectedOrg}
 		}
 
-		result, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs, "open", page)
+		prs, err := h.Client.ListAllPullRequests(r.Context(), token, queryOrgs)
 		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
-			}
+			data.Pulls = prs
 		}
 	}
 
-	// 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")
 	if err != nil {
 		slog.Error("failed to parse pulls template", "error", err)
@@ -430,23 +366,6 @@ func (h *Handler) IssueDetail(w http.ResponseWriter, r *http.Request) {
 		labels = nil
 	}
 
-	collaborators, err := h.Client.ListCollaborators(r.Context(), token, owner, repo)
-	if err != nil {
-		slog.Error("failed to get collaborators", "error", err)
-		collaborators = 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 {
@@ -457,18 +376,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
-		Collaborators   []string
 	}
 
 	data := templateData{
 		Issue:           issue,
-		RenderedBody:    renderedBody,
 		Comments:        comments,
 		AvailableLabels: labels,
-		Collaborators:   collaborators,
 	}
 
 	var buf strings.Builder
@@ -502,17 +417,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 {
@@ -522,13 +426,11 @@ func (h *Handler) PullDetail(w http.ResponseWriter, r *http.Request) {
 	}
 
 	type templateData struct {
-		Pull         *giteaclient.PullRequest
-		RenderedBody template.HTML
+		Pull *giteaclient.PullRequest
 	}
 
 	data := templateData{
-		Pull:         pr,
-		RenderedBody: renderedBody,
+		Pull: pr,
 	}
 
 	var buf strings.Builder
@@ -541,41 +443,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)
@@ -590,12 +457,6 @@ 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
 	}
@@ -603,12 +464,6 @@ 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
 	}
@@ -669,45 +524,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)
 }
 
-// AssignIssue handles POST /issues/{owner}/{repo}/{index}/assignees.
-func (h *Handler) AssignIssue(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
-	}
-
-	assignee := r.FormValue("assignee")
-	if assignee == "" {
-		http.Error(w, "assignee is required", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.AssignIssue(r.Context(), token, owner, repo, index, []string{assignee}); err != nil {
-		slog.Error("failed to assign issue", "error", err, "owner", owner, "repo", repo, "index", index, "assignee", assignee)
-		http.Error(w, "failed to assign issue", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		fmt.Fprintf(w, `<span style="color:#3fb950">Assigned to %s</span>`, template.HTMLEscapeString(assignee))
-		return
-	}
-
-	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)
@@ -736,53 +552,6 @@ func (h *Handler) CloseIssue(w http.ResponseWriter, r *http.Request) {
 	http.Redirect(w, r, fmt.Sprintf("/issues/%s/%s/%d", owner, repo, index), http.StatusSeeOther)
 }
 
-// SetIssueState handles POST /issues/{owner}/{repo}/{index}/state.
-func (h *Handler) SetIssueState(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
-	}
-
-	state := r.FormValue("state")
-	if state != "open" && state != "closed" {
-		http.Error(w, "state must be 'open' or 'closed'", http.StatusBadRequest)
-		return
-	}
-
-	if err := h.Client.SetIssueState(r.Context(), token, owner, repo, index, state); err != nil {
-		slog.Error("failed to set issue state", "error", err, "owner", owner, "repo", repo, "index", index, "state", state)
-		http.Error(w, "failed to update issue state", http.StatusInternalServerError)
-		return
-	}
-
-	if isHTMX(r) {
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		if state == "closed" {
-			fmt.Fprintf(w, `<span class="state-closed" id="issue-state">closed</span>
-<button class="btn btn-secondary" hx-post="/issues/%s/%s/%d/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen Issue</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		} else {
-			fmt.Fprintf(w, `<span class="state-open" id="issue-state">open</span>
-<button class="btn btn-danger" hx-post="/issues/%s/%s/%d/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close Issue</button>`,
-				template.HTMLEscapeString(owner), template.HTMLEscapeString(repo), index)
-		}
-		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)

internal/handlers/handlers_test.go

@@ -135,54 +135,6 @@ func TestSubmitReview_MissingEventType(t *testing.T) {
 	}
 }
 
-func TestSetIssueState_InvalidState(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/1/state", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
-func TestSetIssueState_InvalidIndex(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/state", h.SetIssueState)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/abc/state", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
-func TestAddComment_EmptyBody(t *testing.T) {
-	h := newTestHandler()
-	mux := http.NewServeMux()
-	mux.HandleFunc("POST /issues/{owner}/{repo}/{index}/comments", h.AddComment)
-
-	req := httptest.NewRequest(http.MethodPost, "/issues/org/repo/1/comments", nil)
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-	w := httptest.NewRecorder()
-
-	mux.ServeHTTP(w, req)
-
-	if w.Code != http.StatusBadRequest {
-		t.Errorf("status = %d, want %d", w.Code, http.StatusBadRequest)
-	}
-}
-
 func contains(s, substr string) bool {
 	return len(s) >= len(substr) && searchString(s, substr)
 }

internal/templates/create_issue.html

@@ -1,9 +1,7 @@
 {{define "content"}}
 <h1>Create Issue</h1>
 
-<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">
+<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>
@@ -34,43 +32,11 @@
 </form>
 
 <script>
-  (function() {
-    var repoSelect = document.getElementById('repo-select');
-    var ownerInput = document.getElementById('owner-input');
-    var repoInput = document.getElementById('repo-input');
-    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';
-    });
-  })();
+  // Split owner/repo from select into hidden fields.
+  document.getElementById('repo-select').addEventListener('change', function() {
+    var parts = this.value.split('/');
+    document.getElementById('owner-input').value = parts[0] || '';
+    document.getElementById('repo-input').value = parts[1] || '';
+  });
 </script>
 {{end}}

internal/templates/issue_detail.html

@@ -3,30 +3,19 @@
 
 <div class="card">
   <div class="card-meta">
-    <span id="state-section">
-      {{if eq .Issue.State "closed"}}
-      <span class="state-closed" id="issue-state">{{.Issue.State}}</span>
-      <button class="btn btn-secondary" hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/state" hx-vals='{"state":"open"}' hx-target="#state-section" hx-swap="innerHTML">Reopen Issue</button>
-      {{else}}
-      <span class="state-open" id="issue-state">{{.Issue.State}}</span>
-      <button class="btn btn-danger" hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/state" hx-vals='{"state":"closed"}' hx-target="#state-section" hx-swap="innerHTML">Close Issue</button>
-      {{end}}
-    </span>
+    <span class="state-open">{{.Issue.State}}</span>
     <span>{{.Issue.RepoOwner}}/{{.Issue.RepoName}} #{{.Issue.Number}}</span>
     {{range .Issue.Labels}}
     <span class="label" style="color:#{{.Color}};border:1px solid #{{.Color}}">{{.Name}}</span>
     {{end}}
   </div>
-  {{if .RenderedBody}}
-  <div class="card-body markdown-body">{{.RenderedBody}}</div>
-  {{else if .Issue.Body}}
+  {{if .Issue.Body}}
   <div class="card-body">{{.Issue.Body}}</div>
   {{end}}
 </div>
 
 {{if .Comments}}
 <h2>Comments</h2>
-<div id="comments-list">
 {{range .Comments}}
 <div class="comment">
   <div class="comment-header">
@@ -36,33 +25,10 @@
   <div class="comment-body">{{.Body}}</div>
 </div>
 {{end}}
-</div>
-{{else}}
-<div id="comments-list"></div>
 {{end}}
 
-<div class="card" style="margin-top:1rem;">
-  <h2>Add Comment</h2>
-  <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/comments" hx-target="#comments-list" hx-swap="beforeend" hx-on::after-request="if(event.detail.successful) this.reset()">
-    <textarea name="body" rows="4" placeholder="Write a comment..." required style="width:100%;margin-bottom:0.5rem;"></textarea>
-    <button type="submit" class="btn btn-primary" style="width:auto;padding:0.5rem 1rem;">Comment</button>
-  </form>
-</div>
-
 <div class="card" style="margin-top:1rem;">
   <h2>Actions</h2>
-  {{if .Collaborators}}
-  <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/assignees" hx-swap="outerHTML" style="margin-bottom:0.5rem;">
-    <div class="filter-bar" style="margin-bottom:0.5rem;">
-      <select name="assignee">
-        {{range .Collaborators}}
-        <option value="{{.}}">{{.}}</option>
-        {{end}}
-      </select>
-      <button type="submit" class="btn btn-secondary" style="width:auto;padding:0.5rem 1rem;">Assign</button>
-    </div>
-  </form>
-  {{end}}
   <form hx-post="/issues/{{.Issue.RepoOwner}}/{{.Issue.RepoName}}/{{.Issue.Number}}/labels" hx-swap="outerHTML" style="margin-bottom:0.5rem;">
     <div class="filter-bar" style="margin-bottom:0.5rem;">
       <select name="label_id">

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/layout.html

@@ -13,10 +13,6 @@
   <script src="/static/htmx.min.js"></script>
 </head>
 <body>
-  <header class="top-bar">
-    <span class="top-bar-title">Gitea Mobile</span>
-    <button class="refresh-btn" hx-get="" hx-target="#main-content" hx-swap="innerHTML" aria-label="Refresh">&#8635;</button>
-  </header>
   <div class="content" id="main-content">
     {{template "content" .}}
   </div>

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}}
-  <div class="card-body markdown-body">{{.RenderedBody}}</div>
-  {{else if .Pull.Body}}
+  {{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}}

static/style.css

@@ -47,53 +47,10 @@ body {
   -moz-osx-font-smoothing: grayscale;
 }
 
-/* Top bar */
-.top-bar {
-  position: sticky;
-  top: 0;
-  z-index: 100;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: var(--spacing-sm) var(--spacing-lg);
-  padding-top: max(var(--spacing-sm), env(safe-area-inset-top));
-  background: var(--bg-secondary);
-  border-bottom: 1px solid var(--border);
-}
-
-.top-bar-title {
-  font-size: var(--font-base);
-  font-weight: 600;
-  color: var(--text-primary);
-}
-
-.refresh-btn {
-  background: none;
-  border: none;
-  color: var(--text-secondary);
-  font-size: 1.4rem;
-  padding: var(--spacing-xs) var(--spacing-sm);
-  cursor: pointer;
-  -webkit-tap-highlight-color: transparent;
-  line-height: 1;
-  border-radius: var(--radius-sm);
-  transition: color 0.15s ease, background 0.15s ease;
-}
-
-.refresh-btn:active {
-  color: var(--accent-blue);
-  background: var(--bg-tertiary);
-}
-
-.refresh-btn.htmx-request {
-  animation: spin 0.6s linear infinite;
-  pointer-events: none;
-}
-
 /* Content area */
 .content {
   padding: var(--spacing-lg);
-  padding-top: var(--spacing-lg);
+  padding-top: max(var(--spacing-lg), env(safe-area-inset-top));
   max-width: 640px;
   margin: 0 auto;
 }